Italy Fines Meta €805M: ePrivacy & Android Permission Rules

Italy's Garante has fined Meta €805M for accessing Android gallery data by default, highlighting critical ePrivacy Directive consent requirements for mobile application engineering teams.

TL;DR

  • The Italian Data Protection Authority (Garante) fined Meta €805 million over a Facebook for Android feature that automatically scanned device photo galleries for posting suggestions without explicit consent.
  • The ruling is grounded in Article 122 of Italy’s Privacy Code (transposing EU ePrivacy Directive Article 5(3)), establishing that accessing stored device data requires explicit, informed consent regardless of whether data leaves the client or causes harm.
  • Meta’s reliance on the GDPR One-Stop-Shop (OSS) mechanism failed because ePrivacy rules are transposed into national law, granting independent enforcement authority to every EU national Data Protection Authority (DPA).
  • Mobile operating system runtime permissions (such as Android’s READ_MEDIA_IMAGES) grant binary file-system access but do not constitute valid legal consent for specific background features.
  • Engineering teams must decouple OS-level capability prompts from feature-level consent engines, enforce default-off states retroactively, and build verifiable consent telemetry into mobile builds.

On 14 November 2026, the Italian Data Protection Authority (Garante per la protezione dei dati personali) issued an €805 million fine against Meta following an investigation into Facebook for Android. The sanction targets an automated gallery suggestion feature introduced in 2023 that scanned local photos, videos, and associated EXIF metadata to suggest content for platform uploads. The authority determined that enabling this feature by default without explicit feature-level user consent violated national privacy laws.

The regulatory core of the meta eprivacy fine highlights a critical architectural gap in modern mobile application development: the legal and technical separation between operating system runtime permissions and application-level consent under European Union law. According to reporting by The Hacker News, the Garante confirmed that granting a broad system-level storage permission does not authorise an application to perform continuous background parsing of local file systems for secondary feature suggestions.

The decision disrupts common engineering patterns across mobile platform architectures. Because the Garante enforced national legislation implementing the EU ePrivacy Directive rather than the General Data Protection Regulation (GDPR), Meta was unable to consolidate regulatory oversight under Ireland’s Data Protection Commission (DPC). Mobile app architects and AppSec teams must re-evaluate how terminal equipment storage is accessed, how consent state is persisted, and how client-side processing pipelines are exposed to end users across all EU jurisdictions.

The €805 Million Fine: Technical and Regulatory Core of the Garante Decision

The Garante decision concludes an inquiry that formally began in July 2025 after a complaint filed on 11 July 2025 by consumer protection group Centro Tutela Consumatori Utenti (based in Bolzano). The investigation focused on Facebook for Android’s implementation of automated media upload suggestions. When users granted the application standard Android gallery permissions, the app activated an internal background routine that routinely evaluated newly created photos, videos, and media metadata to generate prompt cards within the application feed.

The authority’s technical analysis revealed that Meta configured this gallery inspection routine to run by default upon receiving broad device-level storage permissions. Users were presented with a generalized initial prompt regarding application features, but the interface failed to explicitly inform them that local media archives would be continuously indexed to drive upload recommendations. Because the underlying runtime permission granted broad read access across the media store, neither the user nor regulatory inspectors could easily audit which local files were evaluated by the background process.

Enforcement Mandate & Deadlines

The Garante imposed a strict remediation timeline on Meta for all Android users in Italy: submit an initial progress report within 30 days, disable the gallery suggestion feature by default for all Italian Android clients within 60 days (including users who previously granted gallery permissions), and file complete proof of compliance within 90 days. If Meta fails to meet the 60-day deadline, the feature must remain completely disabled for any user who has not explicitly opted in through a new compliant consent interface.

The €805 million penalty represents approximately 0.47 percent of Meta’s global annual revenue. In calculating the fine, the Garante cited several aggravating factors:

  • User Scale: The feature directly impacted approximately 20 million Android users in Italy.
  • Duration of Infringement: The non-compliant default configuration persisted from its introduction in 2023 through the 2025–2026 enforcement period.
  • Ongoing Exposure: The violation remained active on un-updated client devices and for accounts where OS-level permissions had already been granted.
  • Regulatory History: The authority factored in a prior 2019 enforcement ruling against Meta and noted limited initial cooperation during technical discovery.

Meta announced plans to appeal the decision, arguing that the feature relied on explicit device-level permissions granted by users and that manual opt-out toggles were available within application settings. However, the Garante ruled that retroactive opt-out controls do not satisfy affirmative consent requirements when accessing local device storage.

ePrivacy Directive vs GDPR: The Failure of the One-Stop-Shop Defence

A fundamental element of Meta’s legal defence was the claim that Ireland’s Data Protection Commission (DPC) held exclusive jurisdiction as the primary supervisory authority under the GDPR’s One-Stop-Shop (OSS) mechanism. The Garante rejected this jurisdictional challenge, drawing a sharp legal boundary between processing personal data under the GDPR and accessing local terminal equipment under the ePrivacy Directive.

The sanction was issued under Article 122 of Italy’s Privacy Code (Codice in materia di protezione dei dati personali), which transposes Article 5(3) of the EU ePrivacy Directive (Directive 2002/58/EC, as amended by Directive 2009/136/EC) into Italian national law. The relationship between these legal frameworks creates distinct jurisdictional pathways:

Regulatory Attribute GDPR (Regulation EU 2016/679) ePrivacy (Directive 2002/58/EC / Art. 122)
Legal Instrument Directly applicable EU Regulation Member State national transposition laws
Lead Authority (OSS) Yes (Single lead DPA based on main establishment) No (Independent national DPA enforcement)
Trigger Event Processing of personal data Accessing or storing data on terminal equipment
Consent Standard Article 6 / Article 7 conditions Strict explicit consent prior to device access
Harm Requirement Evaluated during risk assessment None (Unauthorized access constitutes breach)

The GDPR One-Stop-Shop framework allows multinational technology companies operating a main establishment in an EU member state (such as Meta’s European headquarters in Dublin) to interface primarily with a single lead DPA for cross-border data processing issues. However, the ePrivacy Directive is not an EU-wide regulation; it is a directive implemented through individual statutes across all 27 EU member states.

Because Article 122 of Italy’s Privacy Code governs device access directly within Italian territory, the Garante retained independent legal authority to investigate, audit, and penalise Meta without deferring to the Irish DPC. This enforcement model means that platform operators cannot rely on centralized regulatory relationships in Ireland or Luxembourg to shield their client-side application behavior from direct enforcement by DPAs in Germany, France, Italy, or Spain.

The technical core of the Garante decision exposes a systemic flaw in standard mobile engineering practices: relying on operating system runtime permission prompts to satisfy legal consent requirements. Android’s permission model is designed for access control, not regulatory compliance management.

Beginning in Android 13 (API level 33), Google replaced broad legacy storage access (READ_EXTERNAL_STORAGE) with granular media permissions: READ_MEDIA_IMAGES and READ_MEDIA_VIDEO. When an application requests these permissions, the operating system renders a standard security dialog asking the user to grant or deny access to the file system.

# Example: Typical Android manifest declaring OS-level media access
# AndroidManifest.xml
<uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
<uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />

From an OS execution perspective, once a user taps “Allow”, the application process gains broad access to query media stores through system APIs. In Facebook for Android, receiving this permission triggered two completely separate software paths:

  1. Interactive Flow (Direct Purpose): The user initiates a post, opens the in-app media picker, selects a specific photo, and clicks upload.
  2. Automated Background Flow (Secondary Purpose): A background process registers a content observer or schedule job (e.g., via WorkManager) that queries MediaStore.Images.Media.EXTERNAL_CONTENT_URI whenever new media is added to the local device storage. The job parses EXIF timestamps, location tags, and file properties to construct proactive upload prompts in the user’s feed.

The Garante ruled that conflating these two flows under a single OS permission prompt breaks ePrivacy compliance. The OS prompt asks whether the application may access storage capability, but it does not specify or isolate the distinct business logic features that consume that capability.

System Access vs Legal Authorization

An OS permission grant is a technical gate key; it is not a grant of legal consent for every internal sub-routine that can execute once the gate is unlocked. Mobile app architecture must treat system permission grants as a necessary prerequisite, while managing specific feature execution through independent, application-level consent states.

When an app uses a single OS permission request to unlock both intentional user photo selection and automatic background gallery scanning, the consent fails to meet the legal criteria defined under European law: it is neither specific, informed, nor freely given for the secondary background processing feature.

Local Storage Access and Data Sovereignty under ePrivacy Article 122

A common misconception among mobile software architects is that processing data entirely client-side—without transmitting raw files across the network interface (e.g., wlan0 or cellular)—insulates an application from strict privacy regulation. The Garante’s enforcement action explicitly dismantles this assumption.

Article 122 of Italy’s Privacy Code protects user terminal equipment—smartphones, tablets, and personal computers—as an extension of private life. The law applies to any technical operation that stores information on a device or retrieves information already stored on it. The statutory language does not require data exfiltration, cloud synchronization, or proof of privacy harm to establish a legal violation.

# Logical flow of non-compliant vs compliant local storage access

# NON-COMPLIANT ARCHITECTURE:
[ App Launch ] --> [ Request OS READ_MEDIA_IMAGES ] --> [ Granted ] 
                                                                |
                                                                +--> [ Background Worker Reads MediaStore ]
                                                                +--> [ Local Metadata Indexing ]
                                                                +--> [ Auto-Generate Upload Suggestions ]

# COMPLIANT ARCHITECTURE:
[ App Launch ] --> [ Request OS READ_MEDIA_IMAGES ] --> [ Granted ]
                                                                |
                                                                v
                                              [ Check Internal Consent Engine ]
                                                                |
                                           +--------------------+--------------------+
                                           |                                         |
                                  [ Consent = TRUE ]                        [ Consent = FALSE ]
                                           |                                         |
                                           v                                         v
                            [ Execute Background Indexing ]           [ Suppress Background Scanning ]
                            [ Generate Upload Suggestions ]           [ Only Allow Manual File Picker ]

This statutory interpretation directly impacts client-side machine learning, local search indexing, and automated content caching. If an application deploys an on-device model (such as CoreML or TensorFlow Lite) to parse local camera rolls, categorize image vectors, or process EXIF location records, the execution constitutes active retrieval of stored terminal data. If that background indexing operation runs by default upon receiving broad OS-level permissions, it violates Article 122—even if zero bytes of image data leave the local flash storage.

Evaluating AI Training Claims and Cloud-Based Processing Risks

During the Garante’s proceedings, questions arose regarding whether Meta utilized local gallery media or extracted EXIF metadata to train generative AI models or downstream recommendation algorithms. The Garante clarified in its findings that the scope of this specific investigation and resulting fine did not inspect or evaluate Meta’s AI model training data pipelines.

Meta formally denied utilizing local gallery contents or associated metadata accessed via the Android suggestion feature for AI model training purposes. The Garante recorded this denial but noted that separate processing features introduced later may face technical scrutiny.

Specifically, Meta launched an updated mobile feature in 2026 that allows users to offload gallery content to cloud infrastructure for automated media enhancement and processing. While this 2026 feature was excluded from the €805 million enforcement decision, the Garante explicitly stated that the authority reserves the right to initiate a separate, targeted technical audit into cloud processing workflows.

Cloud Processing Compliance Risk

Offloading client-side media scanning to cloud services shifts the compliance model from local ePrivacy rules directly into GDPR high-risk processing frameworks. Transferring local media metadata to cloud microservices requires formal Data Protection Impact Assessments (DPIAs), updated Privacy Notices, and explicit user-initiated consent prompts prior to payloads crossing the network boundary.

For mobile application developers, connecting client-side gallery indexing to cloud-hosted microservices creates dual regulatory liabilities: ePrivacy Article 122 governs the initial local retrieval from the device media store, while GDPR Articles 6, 9, and 44 govern the subsequent cloud transmission, server-side processing, and international data transfers.

To comply with the Garante ruling, mobile platform engineers must refactor permission models to decouple system-level access grants from feature-level execution logic. Mobile apps must transition to a two-tier authorization architecture.

1. Architecture Pattern: Two-Tier Authorization Engine

Under a two-tier model, system permissions (Tier 1) function strictly as technical access prerequisites. Application-level feature flags (Tier 2) govern whether specific code paths are allowed to invoke those underlying permissions in background contexts.

# Decoupled Feature Gate Execution (Pseudocode Logic)

class GallerySuggestionEngine(
    private val osPermissionChecker: OsPermissionChecker,
    private val consentRepository: FeatureConsentRepository
) {
    fun executeBackgroundGalleryScan() {
        // Tier 1 Check: Does the OS allow reading media?
        if (!osPermissionChecker.hasPermission(Manifest.permission.READ_MEDIA_IMAGES)) {
            Logger.d("OS permission missing. Aborting scan.")
            return
        }

        // Tier 2 Check: Has the user explicitly consented to the specific feature?
        val featureConsent = consentRepository.getConsentStatus(Feature.GALLERY_SUGGESTIONS)
        if (featureConsent != ConsentStatus.GRANTED) {
            Logger.d("ePrivacy feature consent missing or revoked. Aborting background scan.")
            return
        }

        // Both gates passed: Execute local MediaStore indexing
        PerformLocalMediaStoreIndexing()
    }
}

2. Retroactive State Management: Handling Existing Granted Users

The Garante decision explicitly mandates that Meta must disable the gallery suggestion feature by default for all existing Italian Android users—including users who granted OS-level gallery access months or years prior. Mobile software architectures must be capable of executing remote state resets.

Engineering teams must implement a versioned consent state machine within the application’s persistent storage engine (e.g., EncryptedSharedPreferences or Room Database) combined with remote feature flag synchronization:

# Example JSON structure for persisted local consent state
{
  "user_id": "usr_8f93a04b",
  "jurisdiction": "EU_IT",
  "consent_schema_version": 2,
  "features": {
    "core_media_upload": {
      "os_permission_linked": true,
      "requires_explicit_consent": false
    },
    "gallery_background_suggestions": {
      "os_permission_linked": true,
      "requires_explicit_consent": true,
      "consent_state": "DENIED",
      "last_updated_timestamp": "2026-11-15T08:30:00Z",
      "consent_source": "SYSTEM_DEFAULT_RESET"
    }
  }
}

When an updated build launches in an affected jurisdiction, an internal migration script checks the consent_schema_version. If the user has not explicitly signed a Version 2 explicit consent prompt, consent_state defaults to DENIED, regardless of whether READ_MEDIA_IMAGES is enabled in the OS settings.

3. Verifiable Telemetry & Audit Logging

To satisfy regulatory audits under Garante enforcement timelines (30-day progress reporting and 90-day final compliance filing), consent engines must record immutable local audit records whenever a feature consent state changes. The log entry must capture:

  • Target feature identifier (e.g., GALLERY_AUTO_SUGGEST)
  • Consent state value (GRANTED, DENIED, DEFAULT_OFF)
  • Timestamp (ISO-8601 UTC)
  • UI Context ID (identifying the exact modal or settings panel presented to the user)
  • Client application version

Regulatory Blast Radius: Action Plan for Enterprise Mobile App Developers

The enforcement action against Meta establishes a precedent that applies to all enterprise applications distributed within the EU. Mobile architecture and AppSec teams should execute a four-step audit and remediation process to mitigate regulatory exposure across Android and iOS deployments.

Step 1: Inventory Local File System Access Patterns

Audit client-side source code to identify every instance where the application reads terminal storage, camera rolls, system logs, or device metadata. Map every access event to its underlying system API and business logic caller.

# Command-line static analysis to identify MediaStore and file system access points

# Android: Search for MediaStore queries in source files
grep -rnw "./app/src/main/" -e "MediaStore" --include=*.kt --include=*.java

# Android: Search for background work registration referencing media permissions
grep -rnw "./app/src/main/" -e "WorkManager" -e "JobScheduler" --include=*.kt --include=*.java

# iOS: Search for PhotoKit operations
grep -rnw "./ios/" -e "PHFetchResult" -e "PHAsset" -e "PHImageManager" --include=*.swift --include=*.m

Step 2: Audit Default Feature Flags and Background Workers

Review configuration management systems (e.g., LaunchDarkly, Firebase Remote Config, or internal flag engines) to ensure that background indexing processes reading device storage default to false for EU-located users.

Feature Category Technical Execution Pattern Default State (EU) Required Authorization
Manual Media Upload User opens picker -> selects photo Enabled OS Permission only
Automated Gallery Suggestions Background daemon queries MediaStore Default OFF OS Permission + Explicit In-App Consent
On-Device Photo ML Indexing Local background thread generates image embeddings Default OFF OS Permission + Explicit In-App Consent
Local Log Caching Internal application diagnostic logging Enabled Strictly necessary (Exempt under Art. 122)

Step 3: Refactor OS Permission Request Flows

Eliminate application startup prompts that request broad storage permissions before a user attempts to use a specific feature. Bind OS permission calls directly to interactive user events.

  1. Remove Global Startup Prompts: Never execute ActivityCompat.requestPermissions() during application launch or onboarding sequences unless the primary application functionality cannot run without it.
  2. Use Native Pickers Where Possible: On modern Android builds, implement ActivityResultContracts.PickVisualMedia. Native pickers allow users to select specific media items without granting the application broad access to read the entire media library in the background.
# Kotlin code using Android Photo Picker (No OS storage permission required)

val pickMedia = registerForActivityResult(ActivityResultContracts.PickVisualMedia()) { uri ->
    if (uri != null) {
        // User explicitly picked a photo; handle single file access
        processSelectedMedia(uri)
    } else {
        Logger.d("No media selected")
    }
}

// Trigger picker directly on user click
uploadButton.setOnClickListener {
    pickMedia.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly))
}

Collaborate with privacy legal teams to ensure that in-app feature consent prompts explicitly describe:

  • The exact purpose of the local scanning feature.
  • The specific data types accessed (e.g., photos, videos, EXIF location metadata).
  • The local execution mechanics (e.g., “This feature scans your phone’s media storage locally on your device”).
  • A direct link to switch off the feature inside the application’s privacy settings.

Key Takeaways for Engineering and Privacy Leaders

The Italian Garante’s €805 million enforcement decision against Meta redefines operational requirements for software running on mobile devices within the European Union. Engineering and security leaders should incorporate three core technical principles into their mobile platform roadmaps:

  • OS Permissions Do Not Equal Legal Consent: Android runtime permission grants (like READ_MEDIA_IMAGES) unlock operating system access gates, but they do not satisfy ePrivacy requirements for background, feature-level processing. Feature execution must be governed by an independent consent engine.
  • ePrivacy Bypasses the GDPR One-Stop-Shop: Regulatory compliance cannot be funneled solely through a lead DPA under GDPR Article 56. Because national laws like Italy’s Privacy Code Article 122 transpose the ePrivacy Directive locally, every national supervisory authority in the EU possesses independent statutory power to audit and fine mobile app vendors.
  • Default-Off is Mandatory for Secondary Device Access: Any client-side software component that proactively accesses, indexes, or processes stored device content for secondary features—such as photo suggestions, local search indexing, or client-side ML—must be configured to default-off across all EU client builds. Access must remain completely inactive until the user grants explicit, affirmative consent.

Frequently asked questions

Why did the Italian Garante reject Meta’s claim that the Irish DPC should handle this case?

The Garante rejected the claim because the enforcement action was brought under Article 122 of Italy’s Privacy Code, which transposes the EU ePrivacy Directive into national law. Unlike the GDPR, the ePrivacy Directive does not contain a One-Stop-Shop mechanism. Consequently, each EU member state’s Data Protection Authority maintains independent statutory authority to enforce terminal equipment privacy rules directly within its jurisdiction.

Does accessing data locally on a user’s phone violate ePrivacy even if no data is sent to external servers?

Yes. Article 122 of Italy’s Privacy Code and Article 5(3) of the EU ePrivacy Directive protect user terminal equipment as private space. Legally, accessing or parsing data stored locally on a phone requires explicit, prior user consent, regardless of whether that data is exfiltrated over the network or remains entirely on the client device.

What is the technical difference between an Android OS permission prompt and valid ePrivacy consent?

An Android OS permission prompt controls system-level API access to device resources, granting binary read or write capabilities to an application process. Valid ePrivacy consent requires a specific, informed, and unbundled agreement from the user that explains the exact operational purpose of a feature before background processing or media scanning takes place.

How must mobile development teams handle existing users who previously granted broad gallery access?

Teams must deploy application updates that retroactively reset background gallery feature flags to off by default for affected jurisdictions. Even if an existing user previously granted system-level OS gallery permissions, background processing features must remain disabled until the user explicitly opts in through a compliant, specific consent prompt.

Does this ruling impact on-device machine learning features in mobile applications?

Yes. If an on-device machine learning model automatically reads, parses, or indexes local device storage (such as camera rolls or files) in the background without user initiation, it triggers ePrivacy consent requirements. Developers must ensure that local ML indexing features are turned off by default and require an explicit in-app opt-in before executing.

Sources and further reading

This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.