Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Datasekretess och GDPR

Lektion 21 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Datasekretess och GDPR
  2. Hur OpenAI bearbetar din data
  3. Dataminimering
  4. GDPR-kompatibel pipeline
  5. Hantering av samtycke
  6. Rätten till radering (artikel 17)
  7. Checklista för GDPR för utvecklare
  8. Viktiga punkter

Datasekretess och GDPR

Som europeisk utvecklare måste du förstå hur data flödar genom OpenAI API och vilka steg du behöver ta för att följa GDPR (General Data Protection Regulation). Denna lektion täcker de tekniska aspekterna av efterlevnad. Den ersätter inte råd från ditt dataskyddsombud (DPO), men den ger dig de kodningspraxis som gör deras jobb möjligt – och som, om de försummas under designfasen, blir extremt kostsamma att åtgärda senare.

Hur OpenAI bearbetar din data

Via API:t (inte ChatGPT)

Att skilja på API-användning och konsumentanvändning är utgångspunkten för varje diskussion i detta ämne. När du använder OpenAI API för din applikation används data inte för att träna modeller: detta är API-policyt, vilket skiljer sig från ChatGPT:s, och det är argumentet du kommer att använda för att bemöta den vanligaste invändningen i säkerhetskommittéer. Data lagras dock i 30 dagar för att möjliggöra upptäckt av missbruk, varefter den raderas. Du kan förkorta denna lagringstid: du kan begära tidig radering via funktionen Zero Data Retention. En punkt återstår att dokumentera i din konsekvensbedömning – data passerar genom OpenAI:s servrar, som främst är belägna i USA, vilket utgör en överföring utanför Europeiska unionen.

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

Dataminimering

GDPR kräver att endast strikt nödvändig data bearbetas. Tillämpa denna princip på dina API-anrop: i de allra flesta fall har modellen inget behov av att känna till en persons namn, e-postadress eller telefonnummer för att sammanfatta deras begäran eller klassificera dess ämne.

Reversibel pseudonymisering adresserar detta behov exakt. Innan sändning ersätts varje personuppgift med en numrerad markör, och mappningen hålls i minnet på din server. API:t ser endast [EMAIL_1] och [TEL_1]. Vid retur återställs markörerna i den genererade texten, och slutanvändaren får ett komplett svar utan att koordinaterna någonsin lämnar ditt system.

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}")

Titta noga på utdata från detta exempel: “Jean Dupont” finns fortfarande kvar. Räknaren inkluderar en post för name, men inget reguljärt uttryck fyller den – att upptäcka ett efternamn kräver igenkänning av namngivna entiteter, inte ett teckenmönster. Betrakta därför denna funktion som en grund att bygga vidare på, inte som en komplett anonymiseringslösning.

GDPR-kompatibel pipeline

Minimering ensam räcker inte: regleringen kräver också att varje bearbetningsoperation vilar på en identifierad rättslig grund och registreras. Denna pipeline kombinerar båda kraven i fyra steg – registrera syfte och rättslig grund, minimera, anropa, återställ. Användaridentifieraren lagras aldrig i klartext utan hashas, så att registret förblir användbart för att räkna operationer utan att i sig utgöra ett register över personuppgifter.

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())

Parametern legal_basis förtjänar uppmärksamhet: bearbetning av en avbeställningsbegäran faller under fullgörande av avtal, inte samtycke. Att välja fel rättslig grund är det vanligaste och mest konsekvensrika felet, eftersom det avgör vilka rättigheter en användare kan utöva över den bearbetningen.

Hantering av samtycke

När den valda rättsliga grunden är samtycke måste det samlas in, dateras, versionshanteras och framför allt vara återkalleligt. Hanteraren nedan lagrar samtycke per syfte – att acceptera AI-assistans innebär inte acceptans av textanalys – och verifierar denna matchning före varje bearbetningsoperation. Metoden för återkallelse bär på en kritisk kommentar: att radera samtyckesposten räcker inte; du måste också radera den data som berodde på den.

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")

Rätten till radering (artikel 17)

När en användare begär radering av sin data sträcker sig din skyldighet bortom applikationsdatabasen. Du måste rensa alla platser: lokal data, loggar som innehåller personuppgifter – ofta bortglömt – och dokumentera operationen för att kunna motivera den. På API-sidan täcks åtgärden redan av lagringspolicyn: skickad data försvinner automatiskt efter trettio dagar, eller omedelbart om Zero Data Retention är aktiverat.

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")

Checklista för GDPR för utvecklare

  • Identifiera den rättsliga grunden för varje bearbetningsoperation (samtycke, avtal, etc.)
  • Minimera data som skickas till API:t (anonymisering)
  • För ett register över bearbetningsaktiviteter (artikel 30)
  • Implementera rätten till tillgång och rätten till radering
  • Dokumentera överföringar utanför EU (OpenAI = servrar i USA)
  • Aktivera Zero Data Retention om möjligt
  • Logga aldrig personuppgifter i klartext

Viktiga punkter

  • OpenAI API tränar INTE om sina modeller med din data
  • Anonymisera personuppgifter före varje API-anrop
  • För ett register över bearbetningsaktiviteter som följer artikel 30
  • Implementera GDPR-rättigheter: tillgång, rättelse, radering, portabilitet
  • Dataöverföringar utanför EU kräver skyddsåtgärder (standardavtalsklausuler)
  • Dokumentera varje beslut gällande dataskydd