diff --git a/backend/src/app.module.ts b/backend/src/app.module.ts
index 9001cec3..aceba510 100644
--- a/backend/src/app.module.ts
+++ b/backend/src/app.module.ts
@@ -34,7 +34,7 @@ import { AllergiesModule } from './modules/allergies/allergies.module';
 import { ConditionsModule } from './modules/conditions/conditions.module';
 
 import { VerificationModule } from './modules/verification/verification.module';
-import { ZkpModule } from './modules/zkp/zkp.module';
+import { GdprModule } from './modules/gdpr/gdpr.module';
 
 // File Upload & Storage Modules
 import { StorageModule } from './modules/storage/storage.module';
@@ -109,7 +109,7 @@ import { WebSocketModule } from './websocket/websocket.module';
     ConditionsModule,
 
     VerificationModule,
-    ZkpModule,
+    GdprModule,
 
     // File Upload, Storage, Security & Processing
     StorageModule,
diff --git a/backend/src/modules/gdpr/dto/gdpr.dto.ts b/backend/src/modules/gdpr/dto/gdpr.dto.ts
new file mode 100644
index 00000000..2c03fb42
--- /dev/null
+++ b/backend/src/modules/gdpr/dto/gdpr.dto.ts
@@ -0,0 +1,16 @@
+import { IsEnum, IsBoolean, IsOptional, IsString } from 'class-validator';
+import { ConsentType } from '../entities/user-consent.entity';
+
+export class UpdateConsentDto {
+  @IsEnum(ConsentType)
+  type: ConsentType;
+
+  @IsBoolean()
+  granted: boolean;
+}
+
+export class RequestDeletionDto {
+  @IsOptional()
+  @IsString()
+  reason?: string;
+}
diff --git a/backend/src/modules/gdpr/entities/data-deletion-request.entity.ts b/backend/src/modules/gdpr/entities/data-deletion-request.entity.ts
new file mode 100644
index 00000000..1b3bd171
--- /dev/null
+++ b/backend/src/modules/gdpr/entities/data-deletion-request.entity.ts
@@ -0,0 +1,37 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+} from 'typeorm';
+
+export enum DeletionStatus {
+  PENDING = 'pending',
+  PROCESSING = 'processing',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+}
+
+@Entity('data_deletion_requests')
+export class DataDeletionRequest {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ name: 'user_id' })
+  userId: string;
+
+  @Column({ type: 'enum', enum: DeletionStatus, default: DeletionStatus.PENDING })
+  status: DeletionStatus;
+
+  @Column({ type: 'text', nullable: true })
+  reason: string | null;
+
+  @Column({ type: 'jsonb', nullable: true, name: 'deleted_entities' })
+  deletedEntities: Record<string, number> | null;
+
+  @Column({ type: 'timestamptz', nullable: true, name: 'completed_at' })
+  completedAt: Date | null;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+}
diff --git a/backend/src/modules/gdpr/entities/user-consent.entity.ts b/backend/src/modules/gdpr/entities/user-consent.entity.ts
new file mode 100644
index 00000000..74b2cc54
--- /dev/null
+++ b/backend/src/modules/gdpr/entities/user-consent.entity.ts
@@ -0,0 +1,41 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+export enum ConsentType {
+  MARKETING = 'marketing',
+  ANALYTICS = 'analytics',
+  DATA_SHARING = 'data_sharing',
+  ESSENTIAL = 'essential',
+}
+
+@Entity('user_consents')
+export class UserConsent {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ name: 'user_id' })
+  userId: string;
+
+  @Column({ type: 'enum', enum: ConsentType })
+  type: ConsentType;
+
+  @Column({ default: false })
+  granted: boolean;
+
+  @Column({ type: 'inet', nullable: true, name: 'ip_address' })
+  ipAddress: string | null;
+
+  @Column({ nullable: true, name: 'user_agent' })
+  userAgent: string | null;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at' })
+  updatedAt: Date;
+}
diff --git a/backend/src/modules/gdpr/gdpr.controller.ts b/backend/src/modules/gdpr/gdpr.controller.ts
new file mode 100644
index 00000000..ce50e997
--- /dev/null
+++ b/backend/src/modules/gdpr/gdpr.controller.ts
@@ -0,0 +1,70 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Patch,
+  Body,
+  Param,
+  Req,
+  HttpCode,
+  HttpStatus,
+  Headers,
+} from '@nestjs/common';
+import { Request } from 'express';
+import { GdprService } from './gdpr.service';
+import { UpdateConsentDto, RequestDeletionDto } from './dto/gdpr.dto';
+
+@Controller('gdpr')
+export class GdprController {
+  constructor(private readonly gdprService: GdprService) {}
+
+  /** GET /gdpr/users/:userId/consents */
+  @Get('users/:userId/consents')
+  getConsents(@Param('userId') userId: string) {
+    return this.gdprService.getConsents(userId);
+  }
+
+  /** POST /gdpr/users/:userId/consents/init */
+  @Post('users/:userId/consents/init')
+  @HttpCode(HttpStatus.CREATED)
+  initConsents(@Param('userId') userId: string) {
+    return this.gdprService.initDefaultConsents(userId);
+  }
+
+  /** PATCH /gdpr/users/:userId/consents */
+  @Patch('users/:userId/consents')
+  updateConsent(
+    @Param('userId') userId: string,
+    @Body() dto: UpdateConsentDto,
+    @Req() req: Request,
+    @Headers('user-agent') userAgent?: string,
+  ) {
+    const ip = (req.headers['x-forwarded-for'] as string)?.split(',')[0] ?? req.socket.remoteAddress ?? null;
+    return this.gdprService.updateConsent(userId, dto, ip ?? undefined, userAgent);
+  }
+
+  /** POST /gdpr/users/:userId/deletion-request */
+  @Post('users/:userId/deletion-request')
+  @HttpCode(HttpStatus.CREATED)
+  requestDeletion(@Param('userId') userId: string, @Body() dto: RequestDeletionDto) {
+    return this.gdprService.requestDeletion(userId, dto);
+  }
+
+  /** POST /gdpr/deletion-requests/:requestId/process */
+  @Post('deletion-requests/:requestId/process')
+  processDeletion(@Param('requestId') requestId: string) {
+    return this.gdprService.processDeletion(requestId);
+  }
+
+  /** GET /gdpr/users/:userId/deletion-status */
+  @Get('users/:userId/deletion-status')
+  getDeletionStatus(@Param('userId') userId: string) {
+    return this.gdprService.getDeletionStatus(userId);
+  }
+
+  /** GET /gdpr/users/:userId/export */
+  @Get('users/:userId/export')
+  exportData(@Param('userId') userId: string) {
+    return this.gdprService.exportUserData(userId);
+  }
+}
diff --git a/backend/src/modules/gdpr/gdpr.module.ts b/backend/src/modules/gdpr/gdpr.module.ts
new file mode 100644
index 00000000..779ecf27
--- /dev/null
+++ b/backend/src/modules/gdpr/gdpr.module.ts
@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserConsent } from './entities/user-consent.entity';
+import { DataDeletionRequest } from './entities/data-deletion-request.entity';
+import { GdprService } from './gdpr.service';
+import { GdprController } from './gdpr.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([UserConsent, DataDeletionRequest])],
+  controllers: [GdprController],
+  providers: [GdprService],
+  exports: [GdprService],
+})
+export class GdprModule {}
diff --git a/backend/src/modules/gdpr/gdpr.service.ts b/backend/src/modules/gdpr/gdpr.service.ts
new file mode 100644
index 00000000..3dfcf2e0
--- /dev/null
+++ b/backend/src/modules/gdpr/gdpr.service.ts
@@ -0,0 +1,222 @@
+import { Injectable, Logger, NotFoundException, ConflictException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, DataSource } from 'typeorm';
+import { UserConsent, ConsentType } from './entities/user-consent.entity';
+import { DataDeletionRequest, DeletionStatus } from './entities/data-deletion-request.entity';
+import { UpdateConsentDto, RequestDeletionDto } from './dto/gdpr.dto';
+
+@Injectable()
+export class GdprService {
+  private readonly logger = new Logger(GdprService.name);
+
+  constructor(
+    @InjectRepository(UserConsent)
+    private readonly consentRepo: Repository<UserConsent>,
+    @InjectRepository(DataDeletionRequest)
+    private readonly deletionRepo: Repository<DataDeletionRequest>,
+    private readonly dataSource: DataSource,
+  ) {}
+
+  // ── Consent Management ────────────────────────────────────────────────────
+
+  async getConsents(userId: string): Promise<UserConsent[]> {
+    return this.consentRepo.find({ where: { userId }, order: { type: 'ASC' } });
+  }
+
+  async updateConsent(
+    userId: string,
+    dto: UpdateConsentDto,
+    ipAddress?: string,
+    userAgent?: string,
+  ): Promise<UserConsent> {
+    let consent = await this.consentRepo.findOne({ where: { userId, type: dto.type } });
+    if (!consent) {
+      consent = this.consentRepo.create({ userId, type: dto.type });
+    }
+    consent.granted = dto.granted;
+    consent.ipAddress = ipAddress ?? null;
+    consent.userAgent = userAgent ?? null;
+    return this.consentRepo.save(consent);
+  }
+
+  async initDefaultConsents(userId: string): Promise<UserConsent[]> {
+    const existing = await this.consentRepo.find({ where: { userId } });
+    const existingTypes = new Set(existing.map((c) => c.type));
+
+    const defaults = Object.values(ConsentType).filter((t) => !existingTypes.has(t));
+    if (!defaults.length) return existing;
+
+    const entities = defaults.map((type) =>
+      this.consentRepo.create({
+        userId,
+        type,
+        granted: type === ConsentType.ESSENTIAL, // essential always on
+      }),
+    );
+    await this.consentRepo.save(entities);
+    return this.consentRepo.find({ where: { userId } });
+  }
+
+  // ── Right to be Forgotten ─────────────────────────────────────────────────
+
+  async requestDeletion(userId: string, dto: RequestDeletionDto): Promise<DataDeletionRequest> {
+    const pending = await this.deletionRepo.findOne({
+      where: { userId, status: DeletionStatus.PENDING },
+    });
+    if (pending) throw new ConflictException('A deletion request is already pending');
+
+    const request = this.deletionRepo.create({
+      userId,
+      reason: dto.reason ?? null,
+      status: DeletionStatus.PENDING,
+    });
+    return this.deletionRepo.save(request);
+  }
+
+  async processDeletion(requestId: string): Promise<DataDeletionRequest> {
+    const request = await this.deletionRepo.findOne({ where: { id: requestId } });
+    if (!request) throw new NotFoundException(`Deletion request ${requestId} not found`);
+
+    request.status = DeletionStatus.PROCESSING;
+    await this.deletionRepo.save(request);
+
+    const deletedEntities: Record<string, number> = {};
+
+    try {
+      await this.dataSource.transaction(async (em) => {
+        const userId = request.userId;
+
+        // Delete in dependency order — pets cascade to vaccinations, records, etc.
+        const tables: Array<{ table: string; col: string }> = [
+          { table: 'vaccination_adverse_reactions', col: 'vaccination_id' },
+          { table: 'vaccinations', col: 'pet_id' },
+          { table: 'medical_records', col: 'pet_id' },
+          { table: 'prescriptions', col: 'pet_id' },
+          { table: 'surgeries', col: 'pet_id' },
+          { table: 'allergies', col: 'pet_id' },
+          { table: 'conditions', col: 'pet_id' },
+          { table: 'reminders', col: 'pet_id' },
+          { table: 'zkp_proofs', col: 'pet_id' },
+          { table: 'pets', col: 'owner_id' },
+          { table: 'user_consents', col: 'user_id' },
+          { table: 'user_sessions', col: 'user_id' },
+          { table: 'user_activity_logs', col: 'user_id' },
+          { table: 'user_preferences', col: 'user_id' },
+          { table: 'notifications', col: 'user_id' },
+          { table: 'reminders', col: 'user_id' },
+        ];
+
+        for (const { table, col } of tables) {
+          try {
+            const result = await em.query(
+              `DELETE FROM "${table}" WHERE "${col}" = $1`,
+              [userId],
+            );
+            deletedEntities[table] = result[1] ?? 0;
+          } catch {
+            // table may not exist in all environments — skip
+          }
+        }
+
+        // Anonymise user row instead of hard-deleting (audit trail)
+        await em.query(
+          `UPDATE users SET
+            email = $1,
+            first_name = 'Deleted',
+            last_name = 'User',
+            phone = NULL,
+            avatar_url = NULL,
+            address = NULL,
+            city = NULL,
+            country = NULL,
+            date_of_birth = NULL,
+            is_active = false,
+            deleted_at = NOW()
+          WHERE id = $2`,
+          [`deleted-${userId}@deleted.invalid`, userId],
+        );
+        deletedEntities['users'] = 1;
+      });
+
+      request.status = DeletionStatus.COMPLETED;
+      request.completedAt = new Date();
+      request.deletedEntities = deletedEntities;
+    } catch (err) {
+      this.logger.error(`Deletion failed for request ${requestId}: ${err.message}`);
+      request.status = DeletionStatus.FAILED;
+    }
+
+    return this.deletionRepo.save(request);
+  }
+
+  async getDeletionStatus(userId: string): Promise<DataDeletionRequest | null> {
+    return this.deletionRepo.findOne({
+      where: { userId },
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  // ── Data Portability (Export) ─────────────────────────────────────────────
+
+  async exportUserData(userId: string): Promise<Record<string, unknown>> {
+    const rows = await this.dataSource.query(
+      `SELECT id, email, first_name, last_name, phone, city, country, created_at
+       FROM users WHERE id = $1`,
+      [userId],
+    );
+    if (!rows.length) throw new NotFoundException('User not found');
+
+    const [pets] = await Promise.all([
+      this.dataSource.query(`SELECT * FROM pets WHERE owner_id = $1`, [userId]),
+    ]);
+
+    const petIds: string[] = pets.map((p: { id: string }) => p.id);
+
+    const [vaccinations, medicalRecords, prescriptions, consents] = await Promise.all([
+      petIds.length
+        ? this.dataSource.query(`SELECT * FROM vaccinations WHERE pet_id = ANY($1)`, [petIds])
+        : Promise.resolve([]),
+      petIds.length
+        ? this.dataSource.query(`SELECT * FROM medical_records WHERE pet_id = ANY($1)`, [petIds])
+        : Promise.resolve([]),
+      petIds.length
+        ? this.dataSource.query(`SELECT * FROM prescriptions WHERE pet_id = ANY($1)`, [petIds])
+        : Promise.resolve([]),
+      this.dataSource.query(`SELECT type, granted, created_at FROM user_consents WHERE user_id = $1`, [userId]),
+    ]);
+
+    return {
+      exportedAt: new Date().toISOString(),
+      profile: rows[0],
+      pets,
+      vaccinations,
+      medicalRecords,
+      prescriptions,
+      consents,
+    };
+  }
+
+  // ── Retention Policy ──────────────────────────────────────────────────────
+
+  /** Purge soft-deleted users older than retentionDays (default 90) */
+  async purgeExpiredData(retentionDays = 90): Promise<number> {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - retentionDays);
+
+    const result = await this.dataSource.query(
+      `SELECT id FROM users WHERE deleted_at IS NOT NULL AND deleted_at < $1`,
+      [cutoff],
+    );
+
+    let purged = 0;
+    for (const { id } of result) {
+      const req = await this.requestDeletion(id, { reason: 'retention-policy' }).catch(() => null);
+      if (req) {
+        await this.processDeletion(req.id);
+        purged++;
+      }
+    }
+    this.logger.log(`Retention purge: ${purged} users processed`);
+    return purged;
+  }
+}
diff --git a/src/components/PrivacySettings.tsx b/src/components/PrivacySettings.tsx
new file mode 100644
index 00000000..f9177cd2
--- /dev/null
+++ b/src/components/PrivacySettings.tsx
@@ -0,0 +1,136 @@
+'use client';
+
+import { useState } from 'react';
+import { useGdpr } from '@/hooks/useGdpr';
+import { ConsentType } from '@/lib/gdpr';
+
+const CONSENT_LABELS: Record<ConsentType, { label: string; description: string; locked?: boolean }> = {
+  essential: { label: 'Essential', description: 'Required for the service to function.', locked: true },
+  analytics: { label: 'Analytics', description: 'Help us improve by sharing usage data.' },
+  marketing: { label: 'Marketing', description: 'Receive updates and promotional content.' },
+  data_sharing: { label: 'Data Sharing', description: 'Share anonymised data with research partners.' },
+};
+
+interface Props {
+  userId: string;
+}
+
+export default function PrivacySettings({ userId }: Props) {
+  const { consents, loading, error, updateConsent, exportData, requestDeletion } = useGdpr(userId);
+  const [deletionReason, setDeletionReason] = useState('');
+  const [showDeleteConfirm, setShowDeleteConfirm] = useState(false);
+  const [deletionRequested, setDeletionRequested] = useState(false);
+
+  const handleDelete = async () => {
+    const req = await requestDeletion(deletionReason || undefined);
+    if (req) setDeletionRequested(true);
+    setShowDeleteConfirm(false);
+  };
+
+  return (
+    <div className="space-y-6">
+      {/* Consent Management */}
+      <section className="rounded-xl border border-gray-200 dark:border-gray-700 p-5">
+        <h2 className="font-semibold text-gray-900 dark:text-white mb-1">Privacy Preferences</h2>
+        <p className="text-sm text-gray-500 dark:text-gray-400 mb-4">
+          Manage how your data is used. Changes take effect immediately.
+        </p>
+
+        {error && (
+          <div className="text-sm text-red-600 bg-red-50 dark:bg-red-900/20 rounded p-2 mb-3">{error}</div>
+        )}
+
+        <div className="space-y-3">
+          {(Object.keys(CONSENT_LABELS) as ConsentType[]).map((type) => {
+            const meta = CONSENT_LABELS[type];
+            const consent = consents.find((c) => c.type === type);
+            const granted = consent?.granted ?? (type === 'essential');
+
+            return (
+              <div key={type} className="flex items-start justify-between gap-4">
+                <div>
+                  <p className="text-sm font-medium text-gray-800 dark:text-gray-200">{meta.label}</p>
+                  <p className="text-xs text-gray-500 dark:text-gray-400">{meta.description}</p>
+                </div>
+                <button
+                  disabled={meta.locked || loading}
+                  onClick={() => updateConsent(type, !granted)}
+                  className={`relative inline-flex h-6 w-11 shrink-0 rounded-full transition-colors focus:outline-none
+                    ${granted ? 'bg-blue-600' : 'bg-gray-300 dark:bg-gray-600'}
+                    ${meta.locked ? 'opacity-60 cursor-not-allowed' : 'cursor-pointer'}`}
+                  aria-label={`Toggle ${meta.label}`}
+                >
+                  <span
+                    className={`inline-block h-5 w-5 mt-0.5 rounded-full bg-white shadow transform transition-transform
+                      ${granted ? 'translate-x-5' : 'translate-x-0.5'}`}
+                  />
+                </button>
+              </div>
+            );
+          })}
+        </div>
+      </section>
+
+      {/* Data Portability */}
+      <section className="rounded-xl border border-gray-200 dark:border-gray-700 p-5">
+        <h2 className="font-semibold text-gray-900 dark:text-white mb-1">Download Your Data</h2>
+        <p className="text-sm text-gray-500 dark:text-gray-400 mb-3">
+          Export all your data in JSON format (GDPR Article 20).
+        </p>
+        <button
+          onClick={exportData}
+          disabled={loading}
+          className="py-2 px-4 text-sm rounded-lg bg-blue-600 hover:bg-blue-700 text-white disabled:opacity-50 transition-colors"
+        >
+          {loading ? 'Preparing…' : 'Export My Data'}
+        </button>
+      </section>
+
+      {/* Right to be Forgotten */}
+      <section className="rounded-xl border border-red-200 dark:border-red-800 p-5">
+        <h2 className="font-semibold text-red-700 dark:text-red-400 mb-1">Delete My Account</h2>
+        <p className="text-sm text-gray-500 dark:text-gray-400 mb-3">
+          Permanently delete your account and all associated data (GDPR Article 17). This cannot be undone.
+        </p>
+
+        {deletionRequested ? (
+          <div className="text-sm text-green-700 dark:text-green-400 bg-green-50 dark:bg-green-900/20 rounded p-3">
+            Your deletion request has been submitted. You will receive a confirmation once processing is complete.
+          </div>
+        ) : showDeleteConfirm ? (
+          <div className="space-y-3">
+            <textarea
+              value={deletionReason}
+              onChange={(e) => setDeletionReason(e.target.value)}
+              placeholder="Optional: reason for deletion"
+              rows={2}
+              className="w-full text-sm rounded-lg border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-800 p-2 text-gray-800 dark:text-gray-200"
+            />
+            <div className="flex gap-2">
+              <button
+                onClick={handleDelete}
+                disabled={loading}
+                className="py-2 px-4 text-sm rounded-lg bg-red-600 hover:bg-red-700 text-white disabled:opacity-50 transition-colors"
+              >
+                Confirm Delete
+              </button>
+              <button
+                onClick={() => setShowDeleteConfirm(false)}
+                className="py-2 px-4 text-sm rounded-lg border border-gray-300 dark:border-gray-600 text-gray-700 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-gray-800 transition-colors"
+              >
+                Cancel
+              </button>
+            </div>
+          </div>
+        ) : (
+          <button
+            onClick={() => setShowDeleteConfirm(true)}
+            className="py-2 px-4 text-sm rounded-lg border border-red-500 text-red-600 dark:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/20 transition-colors"
+          >
+            Request Account Deletion
+          </button>
+        )}
+      </section>
+    </div>
+  );
+}
diff --git a/src/hooks/useGdpr.ts b/src/hooks/useGdpr.ts
new file mode 100644
index 00000000..1fdd93e6
--- /dev/null
+++ b/src/hooks/useGdpr.ts
@@ -0,0 +1,52 @@
+import { useState, useEffect, useCallback } from 'react';
+import { gdprService, UserConsent, ConsentType } from '@/lib/gdpr';
+
+export function useGdpr(userId: string) {
+  const [consents, setConsents] = useState<UserConsent[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    try {
+      const data = await gdprService.getConsents(userId);
+      if (!data.length) {
+        const defaults = await gdprService.initConsents(userId);
+        setConsents(defaults);
+      } else {
+        setConsents(data);
+      }
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Failed to load consents');
+    } finally {
+      setLoading(false);
+    }
+  }, [userId]);
+
+  useEffect(() => { load(); }, [load]);
+
+  const updateConsent = useCallback(async (type: ConsentType, granted: boolean) => {
+    try {
+      const updated = await gdprService.updateConsent(userId, type, granted);
+      setConsents((prev) => prev.map((c) => (c.type === type ? updated : c)));
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Failed to update consent');
+    }
+  }, [userId]);
+
+  const exportData = useCallback(async () => {
+    setLoading(true);
+    try { await gdprService.exportData(userId); }
+    catch (e) { setError(e instanceof Error ? e.message : 'Export failed'); }
+    finally { setLoading(false); }
+  }, [userId]);
+
+  const requestDeletion = useCallback(async (reason?: string) => {
+    setLoading(true);
+    try { return await gdprService.requestDeletion(userId, reason); }
+    catch (e) { setError(e instanceof Error ? e.message : 'Deletion request failed'); return null; }
+    finally { setLoading(false); }
+  }, [userId]);
+
+  return { consents, loading, error, updateConsent, exportData, requestDeletion };
+}
diff --git a/src/lib/gdpr.ts b/src/lib/gdpr.ts
new file mode 100644
index 00000000..f9f53453
--- /dev/null
+++ b/src/lib/gdpr.ts
@@ -0,0 +1,71 @@
+export type ConsentType = 'marketing' | 'analytics' | 'data_sharing' | 'essential';
+
+export interface UserConsent {
+  id: string;
+  userId: string;
+  type: ConsentType;
+  granted: boolean;
+  updatedAt: string;
+}
+
+export interface DeletionRequest {
+  id: string;
+  userId: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  reason: string | null;
+  createdAt: string;
+  completedAt: string | null;
+}
+
+export const gdprService = {
+  async getConsents(userId: string): Promise<UserConsent[]> {
+    const res = await fetch(`/api/gdpr/${userId}/consents`);
+    if (!res.ok) throw new Error(await res.text());
+    return res.json();
+  },
+
+  async updateConsent(userId: string, type: ConsentType, granted: boolean): Promise<UserConsent> {
+    const res = await fetch(`/api/gdpr/${userId}/consents`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type, granted }),
+    });
+    if (!res.ok) throw new Error(await res.text());
+    return res.json();
+  },
+
+  async initConsents(userId: string): Promise<UserConsent[]> {
+    const res = await fetch(`/api/gdpr/${userId}/consents`, { method: 'POST' });
+    if (!res.ok) throw new Error(await res.text());
+    return res.json();
+  },
+
+  async requestDeletion(userId: string, reason?: string): Promise<DeletionRequest> {
+    const res = await fetch(`/api/gdpr/${userId}/deletion`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ reason }),
+    });
+    if (!res.ok) throw new Error(await res.text());
+    return res.json();
+  },
+
+  async getDeletionStatus(userId: string): Promise<DeletionRequest | null> {
+    const res = await fetch(`/api/gdpr/${userId}/deletion`);
+    if (res.status === 404) return null;
+    if (!res.ok) throw new Error(await res.text());
+    return res.json();
+  },
+
+  async exportData(userId: string): Promise<void> {
+    const res = await fetch(`/api/gdpr/${userId}/export`);
+    if (!res.ok) throw new Error(await res.text());
+    const blob = await res.blob();
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `petchain-data-${userId}.json`;
+    a.click();
+    URL.revokeObjectURL(url);
+  },
+};
diff --git a/src/pages/api/gdpr/[userId]/consents.ts b/src/pages/api/gdpr/[userId]/consents.ts
new file mode 100644
index 00000000..7e90d86c
--- /dev/null
+++ b/src/pages/api/gdpr/[userId]/consents.ts
@@ -0,0 +1,27 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+
+const BACKEND = process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:3001';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const { userId } = req.query as { userId: string };
+
+  if (req.method === 'GET') {
+    const r = await fetch(`${BACKEND}/gdpr/users/${userId}/consents`);
+    return res.status(r.status).json(await r.json());
+  }
+  if (req.method === 'PATCH') {
+    const r = await fetch(`${BACKEND}/gdpr/users/${userId}/consents`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(req.body),
+    });
+    return res.status(r.status).json(await r.json());
+  }
+  if (req.method === 'POST') {
+    // init defaults
+    const r = await fetch(`${BACKEND}/gdpr/users/${userId}/consents/init`, { method: 'POST' });
+    return res.status(r.status).json(await r.json());
+  }
+
+  res.status(405).json({ error: 'Method not allowed' });
+}
diff --git a/src/pages/api/gdpr/[userId]/deletion.ts b/src/pages/api/gdpr/[userId]/deletion.ts
new file mode 100644
index 00000000..b9546349
--- /dev/null
+++ b/src/pages/api/gdpr/[userId]/deletion.ts
@@ -0,0 +1,22 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+
+const BACKEND = process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:3001';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const { userId } = req.query as { userId: string };
+
+  if (req.method === 'POST') {
+    const r = await fetch(`${BACKEND}/gdpr/users/${userId}/deletion-request`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(req.body),
+    });
+    return res.status(r.status).json(await r.json());
+  }
+  if (req.method === 'GET') {
+    const r = await fetch(`${BACKEND}/gdpr/users/${userId}/deletion-status`);
+    return res.status(r.status).json(await r.json());
+  }
+
+  res.status(405).json({ error: 'Method not allowed' });
+}
diff --git a/src/pages/api/gdpr/[userId]/export.ts b/src/pages/api/gdpr/[userId]/export.ts
new file mode 100644
index 00000000..384beb9c
--- /dev/null
+++ b/src/pages/api/gdpr/[userId]/export.ts
@@ -0,0 +1,16 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+
+const BACKEND = process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:3001';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const { userId } = req.query as { userId: string };
+
+  if (req.method === 'GET') {
+    const r = await fetch(`${BACKEND}/gdpr/users/${userId}/export`);
+    const data = await r.json();
+    res.setHeader('Content-Disposition', `attachment; filename="petchain-data-${userId}.json"`);
+    return res.status(r.status).json(data);
+  }
+
+  res.status(405).json({ error: 'Method not allowed' });
+}