sota.io
2026-04-12·13 min read·sota.io team

EU AI Act Article 23: Obligations of Importers of High-Risk AI Systems (2026)

Article 22 established the EU AI Database that providers must register in before placing a high-risk AI system on the market. Article 23 is the next link in the chain: it places independent verification obligations on the importer — the entity that brings a non-EU provider's high-risk AI into the EU market.

Article 23 is a gate article. Its five-point checklist must be cleared before a single unit crosses the border. If any item fails, the importer cannot place the system on the market. And if problems surface after import, the importer cannot simply point upstream — they have their own cooperation, documentation, and corrective-action obligations that run in parallel with the provider's.

Why Art.23 Matters for Developers

Most EU AI Act developer guides focus on providers (the entity that builds and places the system on the market) or deployers (the entity that operates it). Importers are often overlooked — yet they carry significant liability.

An importer under the EU AI Act is any natural or legal person established in the EU that places a high-risk AI system from a third-country provider on the Union market. This includes:

If your company brings a non-EU AI product to European customers, you are likely an importer under Art.23 — whether or not you think of yourself that way.

The penalties for non-compliance align with Art.99: up to €15 million or 3% of global annual turnover for violations related to high-risk AI obligations.

The Five-Point Importer Gate-Check (Art.23(1))

Before placing a high-risk AI system on the Union market, importers must verify five conditions. All five must be satisfied — partial compliance is not sufficient.

Gate 1: Conformity Assessment Completed (Art.43)

The importer must verify that the relevant conformity assessment procedure under Art.43 has been carried out by the provider.

This does not mean the importer repeats the conformity assessment. It means the importer must obtain and review evidence that the assessment was performed:

Practical check: Ask the provider for the conformity assessment report. For self-assessments, this is an internal document the provider holds. For notified body assessments, it is a formal certificate with the notified body number.

Red flag: Provider claims conformity assessment is "in progress" or "not required." Under the EU AI Act, no conformity assessment = the system cannot lawfully enter the EU market.

Gate 2: Technical Documentation Available (Art.11 + Annex IV)

The importer must verify that the provider has drawn up technical documentation in accordance with Art.11 and Annex IV.

The importer does not hold the documentation — the provider does. But the importer must be able to confirm it exists and can be produced on MSA request.

Annex IV technical documentation covers:

Practical check: Request a summary or index of the technical documentation. For audit purposes, obtain a written commitment from the provider that full documentation will be produced within a defined timeframe upon MSA request.

Gate 3: CE Marking Affixed (Art.49)

The importer must verify that the system bears the required CE marking in accordance with Art.49.

For high-risk AI systems that are safety components in Annex II products (Art.6(1)), the CE marking follows the existing product regulation's marking rules. For standalone Annex III systems (Art.6(2)), the CE marking procedure is governed by Art.49.

What to check:

Note: CE marking for pure software products often appears in documentation or the software interface rather than physical packaging.

Gate 4: EU Declaration of Conformity Drawn Up (Art.48)

The importer must verify that the provider has drawn up an EU declaration of conformity under Art.48.

The EU declaration of conformity is a formal document in which the provider declares that the high-risk AI system complies with all applicable requirements. Art.48(2) specifies the mandatory content:

The importer must keep a copy of this declaration for 10 years after the system is placed on the market (Art.23(5)).

Gate 5: EU Database Registration Completed (Art.49)

The importer must verify that the provider has registered the high-risk AI system in the EU AI Database under Art.49.

The EU AI Database (EUAIS) is the public registry where high-risk AI systems are recorded before market placement. Art.22 covers the technical requirements for the database; Art.49 covers the registration obligation for providers.

The importer's check: has the provider completed registration and does the system have a registration number? This number should appear in accompanying documentation.

Why this matters for importers: If the provider has not registered, either the system is not compliant, or the provider genuinely believes it is exempt. The importer must resolve the discrepancy before import — not after.

The Non-Conformity Discovery Protocol (Art.23(2))

Art.23(2) creates a positive obligation to act when an importer discovers problems — before or after placing the system on the market.

Scenario A: Non-Conformity Discovered Before Import

"Where an importer has sufficient reason to believe that a high-risk AI system is not in conformity with this Regulation, the importer shall not place that system on the market until conformity has been established."

This is an absolute prohibition: if you have sufficient reason to believe there is non-conformity, you cannot import. "Sufficient reason" is a lower bar than certainty — you do not need to perform a forensic audit to trigger the obligation. A missing conformity assessment certificate, an incomplete EU declaration, or a provider's failure to produce technical documentation on request are all sufficient.

Scenario B: Risk Discovered After Import

"Where the high-risk AI system presents a risk within the meaning of Article 79(1), the importer shall inform the provider of that system and the market surveillance authorities to that effect."

Art.79(1) defines a "risk" as a characteristic that could adversely affect health, safety, or fundamental rights of persons. If you discover post-import that the system presents such a risk, you must:

  1. Notify the provider immediately
  2. Notify the national market surveillance authority (MSA) of the member state where you are established
  3. Document both notifications (dates, content, responses)

This creates a parallel notification chain alongside the provider's Art.19 serious incident reporting obligation. The importer's Art.23(2) notification is triggered by risk discovery; the provider's Art.19 notification is triggered by an actual serious incident. Both can be triggered by the same event.

IMPORT RISK DISCOVERY TIMELINE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Risk discovered post-import
         │
         ▼
Art.23(2) Notification (Importer)        Art.19 Notification (Provider)
         │                                        │
         ├─ Notify provider immediately           ├─ Notify MSA within 2 working days
         ├─ Notify national MSA                       (death/serious health harm)
         ├─ Document both notifications          ├─ Notify MSA within 15 calendar days
         │                                           (other serious incidents)
         ▼                                        │
Cooperate with MSA investigation ◄───────────────┘
         │
         ▼
Art.23(6): Provide all documentation on reasoned request

Contact Details and Labeling Requirements (Art.23(3))

Art.23(3) requires importers to indicate on the high-risk AI system — or where not possible, on its packaging or accompanying documentation:

This information must be in a language which can be easily understood by users and market surveillance authorities in the member states where the system is placed.

Practical Implementation

For software products:

For hardware AI systems:

Conflict with provider labeling: The provider's name and address (Art.16 obligations) and the importer's name and address (Art.23(3)) must both appear. This is not a conflict — both entities have independent labeling obligations.

Storage and Transport Compliance (Art.23(4))

"Importers shall ensure that, while a high-risk AI system is under their responsibility, storage or transport conditions, where applicable, do not jeopardise its compliance with the requirements set out in Section 2 of this Chapter."

This obligation is most relevant for AI systems embedded in physical hardware (medical devices, industrial equipment, autonomous vehicles). For pure software, storage and transport conditions rarely affect compliance — but the obligation still applies technically.

For hardware AI systems, importers must:

For software AI systems distributed digitally:

Documentation Retention: The 10-Year Obligation (Art.23(5))

Art.23(5) imposes a 10-year documentation retention obligation on importers:

"Importers shall keep a copy of the EU declaration of conformity referred to in Article 48 at the disposal of the market surveillance authorities for a period of 10 years after the high-risk AI system has been placed on the market, and ensure that the technical documentation can be made available to those authorities upon request."

What Importers Must Retain

DocumentRetention PeriodHolder
EU Declaration of Conformity (copy)10 years from market placementImporter holds
Technical documentation10 years from market placementProvider holds; importer ensures availability
Conformity assessment certificate (copy)10 yearsImporter holds
Import gate-check records10 yearsImporter holds
Non-conformity/risk notificationsUntil case resolution + 10 yearsImporter holds

Critical distinction: The importer holds the EU declaration of conformity copy directly. For technical documentation, the importer's obligation is to ensure the provider keeps it available for MSA requests — not to hold it themselves. This requires a contractual mechanism with the provider.

Contractual Protection

Standard import contracts should include:

  1. Provider warranty that conformity assessment is complete and documentation is held
  2. Obligation on provider to retain technical documentation for 10 years from EU market placement
  3. Provider obligation to produce documentation to EU MSAs within defined response time
  4. Importer right to audit provider's documentation compliance
  5. Indemnification for importer if provider fails to produce documentation on MSA request

MSA Cooperation Obligations (Art.23(6))

Art.23(6) creates a broad cooperation obligation:

"Importers shall, upon reasoned request by a competent authority, provide that authority with all the information and documentation, in paper or electronic form, necessary to demonstrate the conformity of a high-risk AI system with Section 2 of this Chapter, in a language which can be easily understood by that authority."

The importer must:

Art.23(6) also specifies that importers must ensure the provider retains technical documentation and must cooperate with MSAs on any action relating to the system — even if the action is directed primarily at the provider.

Art.23 vs Art.16: Importer vs Provider Obligations

The relationship between Art.23 (importers) and Art.16 (providers) is often confused.

DimensionArt.16 ProviderArt.23 Importer
Creates the systemYesNo
Conducts conformity assessmentYes (Art.43)Verifies it was done
Holds technical documentationYes (Art.11 + Annex IV)Ensures availability
Holds EU declaration of conformityYes (Art.48)Keeps copy for 10 years
CE markingAffixes itVerifies it's affixed
EU database registrationRegisters (Art.49)Verifies registration
Post-market monitoringPrimary obligation (Art.18)Risk notification (Art.23(2))
Corrective actionsPrimary obligation (Art.20)Cooperates with MSA
Serious incident reportingPrimary obligation (Art.19)Risk notification (Art.23(2))

Key principle: The provider is always the primary compliance actor. The importer is a secondary gate that cannot replace the provider's obligations but adds an independent EU-side verification layer.

Art.23 × Art.25: The Supply Chain Responsibility Interaction

Art.25 governs responsibilities along the AI value chain — what happens when multiple entities share provider-like roles. Art.23 and Art.25 interact in a specific pattern.

Scenario: A US AI company builds a high-risk AI system. An EU company licenses and repackages it under their own brand before placing it on the EU market.

Under Art.25, the EU company that rebrands becomes the provider (not just an importer) because they place it under their name. They inherit all Art.16 obligations.

Under Art.23, if the EU company imports the underlying system from the US company and adds their brand, they have dual obligations: both the importer's Art.23 gate-check AND the provider's Art.16 obligations.

This is a critical compliance risk: many European technology companies that resell or white-label non-EU AI tools may unknowingly be classified as providers under Art.25, not merely importers under Art.23. The compliance burden is substantially higher.

EU AI VALUE CHAIN — IMPORTER vs PROVIDER STATUS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Scenario A: Pure Import
US Provider → EU Importer → EU Customer
                ↑ Art.23 obligations only

Scenario B: Rebrand/White-Label
US Supplier → EU Company (rebrand) → EU Customer
               ↑ Art.25 → EU Company = PROVIDER
                  Art.16 obligations PLUS
                  Art.23 gate-check on import

Scenario C: Component Integration
US Component → EU Integrator → EU Customer
                ↑ Art.25 → if substantial modification
                  EU Integrator = PROVIDER
                  Art.16 obligations apply

CLOUD Act Implications for Importer Documentation

Article 23(5) requires importers to hold copies of the EU declaration of conformity and ensure technical documentation availability for 10 years. This documentation is subject to the same CLOUD Act risk as provider documentation.

The CLOUD Act (Clarifying Lawful Overseas Use of Data Act) allows US authorities to compel US cloud providers to produce data stored anywhere — including EU-based storage — if the cloud provider is US-controlled.

What this means for importers:

Documentation TypeCLOUD Act RiskRecommended Storage
EU declaration of conformity (copy)Medium — contains provider attestationsEU-sovereign storage
Conformity assessment reportsHigh — reveals AI system architectureEU-sovereign storage, on-premise
Import gate-check recordsMedium — reveals importer's verification processEU-sovereign storage
Non-conformity notificationsHigh — contains MSA communicationsEU-sovereign storage, encrypted
Provider contractsHigh — reveals supply chain structureEU-sovereign storage, lawyer-privilege consideration

For importers of sensitive high-risk AI (biometrics, law enforcement, critical infrastructure), keeping compliance documentation on US-controlled cloud infrastructure creates a jurisdiction conflict: EU MSAs require access for conformity verification; US authorities may compel access under CLOUD Act. EU-native infrastructure eliminates this conflict.

Python Implementation: Importer Compliance Gateway

from dataclasses import dataclass, field
from datetime import date, datetime
from enum import Enum
from typing import Optional
import hashlib


class GateStatus(Enum):
    PASSED = "passed"
    FAILED = "failed"
    PENDING = "pending"
    NOT_APPLICABLE = "not_applicable"


@dataclass
class ConformityGate:
    """One of the five Art.23(1) gate-check items."""
    gate_id: int
    name: str
    article_ref: str
    status: GateStatus = GateStatus.PENDING
    evidence_ref: Optional[str] = None
    verified_by: Optional[str] = None
    verified_date: Optional[date] = None
    notes: str = ""

    def pass_gate(self, evidence_ref: str, verified_by: str) -> None:
        self.status = GateStatus.PASSED
        self.evidence_ref = evidence_ref
        self.verified_by = verified_by
        self.verified_date = date.today()

    def fail_gate(self, notes: str) -> None:
        self.status = GateStatus.FAILED
        self.notes = notes


@dataclass
class ImporterGateCheck:
    """
    EU AI Act Art.23(1) five-point conformity gate-check.
    All five gates must PASS before market placement.
    """
    system_slug: str
    provider_name: str
    provider_country: str  # Non-EU country of origin
    import_date: Optional[date] = None

    gates: list[ConformityGate] = field(default_factory=lambda: [
        ConformityGate(1, "Conformity Assessment Completed", "Art.43"),
        ConformityGate(2, "Technical Documentation Available", "Art.11 + Annex IV"),
        ConformityGate(3, "CE Marking Affixed", "Art.49(1)"),
        ConformityGate(4, "EU Declaration of Conformity Drawn Up", "Art.48"),
        ConformityGate(5, "EU Database Registration Completed", "Art.49(2)"),
    ])

    def all_gates_passed(self) -> bool:
        return all(g.status == GateStatus.PASSED for g in self.gates)

    def can_place_on_market(self) -> bool:
        """Art.23(1): all five gates must pass."""
        return self.all_gates_passed()

    def failed_gates(self) -> list[ConformityGate]:
        return [g for g in self.gates if g.status == GateStatus.FAILED]

    def pending_gates(self) -> list[ConformityGate]:
        return [g for g in self.gates if g.status == GateStatus.PENDING]

    def gate_summary(self) -> dict:
        return {
            "system": self.system_slug,
            "can_import": self.can_place_on_market(),
            "gates": [
                {
                    "id": g.gate_id,
                    "name": g.name,
                    "status": g.status.value,
                    "evidence": g.evidence_ref,
                }
                for g in self.gates
            ],
        }


@dataclass
class Art23NonConformityNotification:
    """
    Art.23(2) notification when importer discovers non-conformity or risk.
    Both provider and MSA must be notified.
    """
    system_slug: str
    discovery_date: date
    discovery_description: str
    presents_art79_risk: bool  # True = notify MSA

    provider_notified: bool = False
    provider_notification_date: Optional[date] = None
    provider_notification_ref: str = ""

    msa_notified: bool = False
    msa_notification_date: Optional[date] = None
    msa_authority: str = ""
    msa_notification_ref: str = ""

    def notify_provider(self, notification_ref: str) -> None:
        self.provider_notified = True
        self.provider_notification_date = date.today()
        self.provider_notification_ref = notification_ref

    def notify_msa(self, authority: str, notification_ref: str) -> None:
        if not self.presents_art79_risk:
            raise ValueError(
                "MSA notification only required under Art.23(2) when Art.79(1) risk is present"
            )
        self.msa_notified = True
        self.msa_notification_date = date.today()
        self.msa_authority = authority
        self.msa_notification_ref = notification_ref

    def is_complete(self) -> bool:
        provider_ok = self.provider_notified
        msa_ok = (not self.presents_art79_risk) or self.msa_notified
        return provider_ok and msa_ok


@dataclass
class ImporterDocumentRecord:
    """
    Art.23(5) documentation retention record.
    EU declaration of conformity must be kept for 10 years.
    """
    system_slug: str
    market_placement_date: date
    declaration_of_conformity_ref: str
    declaration_hash: str  # SHA-256 of declaration document
    storage_location: str  # Must be EU-sovereign
    technical_doc_provider_commitment_ref: str  # Contractual commitment from provider

    @property
    def retention_deadline(self) -> date:
        """Art.23(5): 10 years from market placement."""
        return self.market_placement_date.replace(
            year=self.market_placement_date.year + 10
        )

    @property
    def days_remaining(self) -> int:
        delta = self.retention_deadline - date.today()
        return delta.days

    def is_within_retention_period(self) -> bool:
        return date.today() <= self.retention_deadline


class ImporterComplianceGateway:
    """
    Manages the full Art.23 importer compliance lifecycle:
    - Gate-check before import
    - Non-conformity notifications
    - Documentation retention tracking
    """

    def __init__(self, importer_name: str, importer_address: str):
        self.importer_name = importer_name
        self.importer_address = importer_address
        self._gate_checks: dict[str, ImporterGateCheck] = {}
        self._notifications: list[Art23NonConformityNotification] = []
        self._doc_records: dict[str, ImporterDocumentRecord] = {}

    def start_gate_check(
        self, system_slug: str, provider_name: str, provider_country: str
    ) -> ImporterGateCheck:
        check = ImporterGateCheck(system_slug, provider_name, provider_country)
        self._gate_checks[system_slug] = check
        return check

    def attempt_import(self, system_slug: str) -> tuple[bool, list[str]]:
        """
        Art.23(1): Can this system be placed on the EU market?
        Returns (can_import, list_of_blockers).
        """
        check = self._gate_checks.get(system_slug)
        if not check:
            return False, ["No gate-check initiated for this system"]

        if check.can_place_on_market():
            check.import_date = date.today()
            return True, []

        blockers = [
            f"Gate {g.gate_id} FAILED ({g.name}): {g.notes}"
            for g in check.failed_gates()
        ] + [
            f"Gate {g.gate_id} PENDING ({g.name}): verification not complete"
            for g in check.pending_gates()
        ]
        return False, blockers

    def record_non_conformity(
        self,
        system_slug: str,
        description: str,
        presents_risk: bool,
    ) -> Art23NonConformityNotification:
        notification = Art23NonConformityNotification(
            system_slug=system_slug,
            discovery_date=date.today(),
            discovery_description=description,
            presents_art79_risk=presents_risk,
        )
        self._notifications.append(notification)
        return notification

    def register_document_retention(
        self,
        system_slug: str,
        placement_date: date,
        declaration_ref: str,
        declaration_document_bytes: bytes,
        storage_location: str,
        provider_commitment_ref: str,
    ) -> ImporterDocumentRecord:
        record = ImporterDocumentRecord(
            system_slug=system_slug,
            market_placement_date=placement_date,
            declaration_of_conformity_ref=declaration_ref,
            declaration_hash=hashlib.sha256(declaration_document_bytes).hexdigest(),
            storage_location=storage_location,
            technical_doc_provider_commitment_ref=provider_commitment_ref,
        )
        self._doc_records[system_slug] = record
        return record

    def compliance_audit(self) -> dict:
        """Full Art.23 compliance status overview."""
        gate_summary = [
            check.gate_summary()
            for check in self._gate_checks.values()
        ]
        doc_summary = [
            {
                "system": slug,
                "retention_deadline": str(record.retention_deadline),
                "days_remaining": record.days_remaining,
                "storage": record.storage_location,
            }
            for slug, record in self._doc_records.items()
        ]
        incomplete_notifications = [
            {
                "system": n.system_slug,
                "provider_notified": n.provider_notified,
                "msa_notified": n.msa_notified,
            }
            for n in self._notifications
            if not n.is_complete()
        ]
        return {
            "importer": self.importer_name,
            "gate_checks": gate_summary,
            "documentation": doc_summary,
            "incomplete_notifications": incomplete_notifications,
        }

Art.23 Compliance Checklist — 30 Items

Pre-Import: Gate-Check (Art.23(1))

Labeling and Storage (Art.23(3-4))

Documentation Retention (Art.23(5))

Non-Conformity and Risk Protocol (Art.23(2))

MSA Cooperation (Art.23(6))

Common Importer Mistakes

Mistake 1: Treating conformity assessment as the provider's problem only. Art.23 places an independent obligation on the importer to verify it happened. "I trusted the provider" is not a defence if the conformity assessment was never completed.

Mistake 2: Not keeping the EU declaration of conformity copy. The provider holds the original. The importer must keep their own copy for 10 years. This is a separate obligation — if the provider goes out of business or the relationship ends, the importer still needs their copy.

Mistake 3: Misidentifying as an importer when Art.25 makes you a provider. If you rebrand, substantially modify, or place a third-country AI system on the market under your own name, Art.25 classifies you as the provider — with all of Art.16's obligations in addition to Art.23's.

Mistake 4: Missing the CE marking verification. Software products don't always have visible CE markings. The obligation still applies — the marking just appears in documentation or the software interface. Failure to verify means gate 3 is incomplete.

Mistake 5: Not establishing contractual documentation retention with the provider. The importer's Art.23(5) obligation for technical documentation requires that the provider keep it available. Without a contractual mechanism, the importer cannot fulfill this obligation if the provider stops cooperating.

Related Articles