Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Príobháideacht Sonraí agus an GDPR

Ceacht 21 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Príobháideacht Sonraí agus an GDPR
  2. Conas a Phróiseálann OpenAI Do Chuid Sonraí
  3. Íoslaghdú Sonraí
  4. Píblíne atá Comhlíontach leis an GDPR
  5. Bainistiú Toilithe
  6. Ceart ar Scriosadh (Airteagal 17)
  7. Seicliosta GDPR d’Fhorbróirí
  8. Príomhphointí

Príobháideacht Sonraí agus an GDPR

Mar fhorbróir Eorpach, caithfidh tú a thuiscint conas a shreabhann sonraí tríd an OpenAI API agus cé na céimeanna atá le glacadh chun an GDPR (An Rialachán Ginearálta maidir le Cosaint Sonraí) a chomhlíonadh. Clúdaíonn an ceacht seo gnéithe teicniúla an chomhlíonta. Ní chuirtear in ionad comhairle ó d’Oifigeach Cosanta Sonraí (DPO) é, ach tugann sé na cleachtais chódúcháin a dhéanfaidh a gcuid oibre indéanta—cleachtais a éireoidh thar a bheith costasach a dheisiú ina dhiaidh sin má dhéantar neamhaird orthu le linn an deartha.

Conas a Phróiseálann OpenAI Do Chuid Sonraí

Tríd an API (seachas ChatGPT)

Is é idirdhealú a dhéanamh idir úsáid an API agus úsáid tomhaltóirí an pointe tosaigh d’aon phlé ar an ábhar seo. Nuair a úsáideann tú an OpenAI API do d’fheidhmchlár, ní úsáidtear sonraí chun samhlacha a oiliúint: sin polasaí an API, atá difriúil ó pholasaithe ChatGPT, agus is é an argóint é a úsáidfidh tú chun freagairt don agóid is coitianta i gcoistí slándála. Mar sin féin, coinnítear sonraí ar feadh 30 lá chun brath ar mhí-úsáid a chumasú, agus scriostar iad ina dhiaidh sin. Is féidir leat an tréimhse coinneála seo a ghiorrú: is féidir leat scriosadh luath a iarraidh tríd an ngné Zero Data Retention. Tá pointe amháin fós le doiciméadú i do mheastóireacht tionchair—trasnaíonn sonraí freastalaithe OpenAI, atá suite go príomha sna Stáit Aontaithe, rud a dhéanann aistriú lasmuigh den Aontas Eorpach de.

# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls

Íoslaghdú Sonraí

Éilíonn an GDPR nach bpróiseáiltear ach sonraí atá go hiomlán riachtanach. Cuir an prionsabal seo i bhfeidhm ar do ghlaoithe API: sa chuid is mó de chásanna, níl aon ghá ag an tsamhail le hainm duine, seoladh ríomhphoist, nó uimhir theileafóin a bheith ar eolas aici chun a n-iarratas a achoimriú nó ábhar a aicmiú.

Freagraíonn bréaganaimniú inbhéartaithe ar an riachtanas seo go beacht. Sula seoltar, cuirtear marcóir uimhrithe in ionad gach píosa sonraí pearsanta, agus coinnítear an mapáil sa chuimhne ar do fhreastalaí. Ní fheiceann an API ach [EMAIL_1] agus [TEL_1]. Nuair a fhilltear, athchuirtear na marcóirí sa téacs ginte, agus faigheann an t-úsáideoir deiridh freagra iomlán gan comhordanáidí a fhágáil do chóras riamh.

import re

def anonymize_before_send(text: str) -> tuple[str, dict]:
    """Anonymizes personal data before sending to the API."""
    replacements = {}
    counter = {"email": 0, "phone": 0, "name": 0}

    # Emails
    def replace_email(match):
        counter["email"] += 1
        key = f"[EMAIL_{counter['email']}]"
        replacements[key] = match.group()
        return key

    text = re.sub(
        r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
        replace_email, text
    )

    # French phone numbers
    def replace_phone(match):
        counter["phone"] += 1
        key = f"[TEL_{counter['phone']}]"
        replacements[key] = match.group()
        return key

    text = re.sub(
        r'\b(?:0|\+33)\s*[1-9](?:[\s.-]*\d{2}){4}\b',
        replace_phone, text
    )

    return text, replacements

def restore_data(text: str, replacements: dict) -> str:
    """Restores data after API processing."""
    for key, value in replacements.items():
        text = text.replace(key, value)
    return text

# Usage
from openai import OpenAI
client = OpenAI()

original_text = "Contact Jean Dupont at [email protected] or 06 12 34 56 78"

# Anonymize
anonymous_text, mapping = anonymize_before_send(original_text)
print(f"Sent to API: {anonymous_text}")
# Sent to API: Contact Jean Dupont at [EMAIL_1] or [TEL_1]

# API call with anonymized data
response = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Summarize this message: {anonymous_text}"
)

# Restore
result = restore_data(response.output_text, mapping)
print(f"Final result: {result}")

Féach go géar ar aschur an tsampla seo: tá “Jean Dupont” fós ann. Tá iontráil sa chuntar do name, ach ní líonann aon slonn rialta é—teastaíonn aitheantas eintitis ainmnithe chun sloinne a bhrath, seachas patrún carachtair. Dá bhrí sin, meas an fheidhm seo mar bhunús le tógáil air, ní mar réiteach bréaganaimnithe iomlán.

Píblíne atá Comhlíontach leis an GDPR

Ní leor an t-íoslaghdú amháin: éilíonn an rialachán freisin go mbíonn bonn dlíthiúil sainaitheanta ag gach oibríocht próiseála agus go ndéantar taifead di. Comhcheanglaíonn an phíblíne seo an dá riachtanas i gceithre chéim—taifead an cuspóir agus an bonn dlíthiúil, íoslaghdaigh, glaoigh, athchuir. Ní stóráiltear an t-aitheantóir úsáideora riamh i ngnáth-théacs ach déantar hais air, ionas go bhfanann an clár inúsáidte chun oibríochtaí comhairimh a dhéanamh gan é féin a bheith ina chomhad de shonraí pearsanta.

from datetime import datetime
import json
import hashlib

class GDPRCompliantPipeline:
    """GDPR-compliant processing pipeline."""

    def __init__(self):
        self.client = OpenAI()
        self.processing_logs = []

    def process(self, text: str, purpose: str,
                legal_basis: str, user_id: str) -> str:
        """Processes text in compliance with GDPR."""

        # 1. Record the legal basis of processing
        processing = {
            "timestamp": datetime.now().isoformat(),
            "user_hash": hashlib.sha256(user_id.encode()).hexdigest()[:12],
            "purpose": purpose,
            "legal_basis": legal_basis,  # consent, legitimate_interest, contract
        }

        # 2. Minimize data
        anonymous_text, mapping = anonymize_before_send(text)

        # 3. API call
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=anonymous_text,
            # Store for the shortest time possible
        )

        processing["tokens_used"] = response.usage.total_tokens
        self.processing_logs.append(processing)

        # 4. Restore and return
        return restore_data(response.output_text, mapping)

    def export_register(self) -> str:
        """Exports the record of processing activities (Article 30 GDPR)."""
        return json.dumps(self.processing_logs, indent=2, ensure_ascii=False)

# Usage
pipeline = GDPRCompliantPipeline()

result = pipeline.process(
    text="Customer Pierre Martin wishes to cancel his subscription.",
    purpose="Cancellation request processing",
    legal_basis="contract",
    user_id="user-456"
)
print(result)
print(pipeline.export_register())

Tuilleann an paraiméadar legal_basis aird: tit próiseáil iarratais cealaithe faoi fheidhmíocht conartha, ní faoi thoiliú. Is é an roghnú mícheart don bhonn dlíthiúil an earráid is minice agus is suntasaí, mar cinneann sé na cearta is féidir le húsáideoir a fheidhmiú thar an bpróiseáil sin.

Bainistiú Toilithe

Nuair is é toiliú an bonn dlíthiúil a roghnaítear, ní mór é a bhailiú, a dhátú, a leaganú, agus thar aon rud eile, caithfidh sé a bheith inbhéartaithe. Stórálann an bainisteoir thíos toiliú de réir cuspóra—ní hionann glacadh le cúnamh AI agus glacadh le hanailís téacs—a dearbhaíonn an meaitseáil seo roimh gach oibríocht próiseála. Tá nóta criticiúil sa mhodh tarraingt siar: ní leor an taifead toilithe a scriosadh; caithfidh tú na sonraí a bhraitheann air a scriosadh freisin.

class ConsentManager:
    """Manages user consent for AI processing."""

    def __init__(self):
        self.consents: dict[str, dict] = {}

    def record_consent(self, user_id: str, purposes: list[str]):
        """Records user consent."""
        self.consents[user_id] = {
            "purposes": purposes,
            "date": datetime.now().isoformat(),
            "version": "v1.0"
        }

    def verify_consent(self, user_id: str, purpose: str) -> bool:
        """Checks if the user has consented to a purpose."""
        consent = self.consents.get(user_id)
        if not consent:
            return False
        return purpose in consent["purposes"]

    def withdraw_consent(self, user_id: str):
        """Withdraws consent (right to withdraw)."""
        if user_id in self.consents:
            del self.consents[user_id]
            # Here: also delete associated data

# Usage
consent = ConsentManager()

# User consents to AI processing
consent.record_consent("user-123", ["ai_assistance", "text_analysis"])

# Verify before every processing operation
if consent.verify_consent("user-123", "ai_assistance"):
    # Proceed with processing
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="User question"
    )
else:
    print("Consent required for this processing")

Ceart ar Scriosadh (Airteagal 17)

Nuair a iarrann úsáideoir a chuid sonraí a scriosadh, síneann do oibleagáid thar bhunachar sonraí an fheidhmchláir. Caithfidh tú gach suíomh a ghlanadh: sonraí áitiúla, logaí ina bhfuil faisnéis phearsanta—rud a dhéantar dearmad go minic orthu—agus doiciméadaigh an oibríocht chun údar a thabhairt léi. Ar thaobh an API, tá an gníomh cumhdaithe cheana féin ag an bpolasaí coinneála: imíonn sonraí seolta go huathoibríoch tar éis tríocha lá, nó láithreach má tá Zero Data Retention cumasaithe.

def exercise_right_to_erasure(user_id: str):
    """Implements the GDPR right to erasure."""

    # 1. Delete local data
    # delete_user_data(user_id)

    # 2. Data sent to the OpenAI API is deleted
    # automatically after 30 days (or immediately
    # with Zero Data Retention enabled)

    # 3. Delete logs containing personal data
    # delete_user_logs(user_id)

    # 4. Document the deletion
    log = {
        "action": "right_to_erasure",
        "user_hash": hashlib.sha256(user_id.encode()).hexdigest()[:12],
        "date": datetime.now().isoformat(),
        "data_deleted": [
            "conversation_history",
            "user_profile",
            "activity_logs"
        ]
    }
    print(json.dumps(log, indent=2, ensure_ascii=False))

exercise_right_to_erasure("user-123")

Seicliosta GDPR d’Fhorbróirí

  • Aithin an bonn dlíthiúil do gach oibríocht próiseála (toiliú, conradh, srl.)
  • Íoslaghdaigh na sonraí a sheoltar chuig an API (bréaganaimniú)
  • Coinnigh clár de ghníomhaíochtaí próiseála (Airteagal 30)
  • Cuir i bhfeidhm an ceart rochtana agus an ceart ar scriosadh
  • Doiciméadaigh aistrithe lasmuigh den AE (OpenAI = freastalaithe SA)
  • Cumasigh Zero Data Retention más féidir
  • Ná déan logáil riamh ar shonraí pearsanta i ngnáth-théacs

Príomhphointí

  • NÍ athoibríonn an OpenAI API a chuid samhlacha le do chuid sonraí
  • Déan bréaganaimniú ar shonraí pearsanta roimh gach glao API
  • Coinnigh clár de ghníomhaíochtaí próiseála atá comhlíontach le hAirteagal 30
  • Cuir cearta GDPR i bhfeidhm: rochtain, ceartú, scriosadh, iniomparthacht
  • Teastaíonn cosaintí d’aistrithe sonraí lasmuigh den AE (clásail chaighdeánacha conarthacha)
  • Doiciméadaigh gach cinneadh maidir le cosaint sonraí