# EUDAMED Medical Device Lookup – UDI, SRN, Class (`lwsdjfls/eudamed-device-lookup`) Actor EUDAMED lookup for medtech regulatory affairs and procurement: find EU medical devices by UDI-DI, manufacturer SRN, product name, risk class or EMDN code, with manufacturer, authorised representative, status, registration date and notified-body certificates. Monitor mode reports new registrations. - **URL**: https://apify.com/lwsdjfls/eudamed-device-lookup.md - **Developed by:** [Leyten Data](https://apify.com/lwsdjfls) (community) - **Categories:** Business, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $50.00 / 1,000 device delivereds This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ### What does EUDAMED Medical Device Lookup do? **EUDAMED lookup** for medtech regulatory affairs, distributors, hospital procurement and market analysts: look up any device in the EU medical device database by UDI-DI, Basic UDI-DI, manufacturer SRN, product name, risk class or EMDN code, and get one record with the device identification, manufacturer, authorised representative, risk class and legislation, market status, registration date, EMDN nomenclature and the notified-body certificates behind it. Switch to **monitor mode** and every new registration in a risk class, nomenclature branch or competitor's portfolio, and every status or certificate change of a watched device, arrives as a dataset item the day EUDAMED shows it. #### Why now Since **28 May 2026** the use of EUDAMED's Actor, UDI/Devices, Certificates and Market Surveillance modules is mandatory (Commission Decision (EU) 2025/2371): a device may only be placed on the EU market once it is registered, and legacy devices must be registered by November 2026. The public registers hold **3.5 million UDI-DIs** and grow by some 15,000 device versions a day. For the first time, the complete EU device landscape is public, current and machine-readable; the catch is that the Commission's web application answers one screen at a time, in five separate modules. #### Monitor mode: competitive intelligence from the register Set `mode` to `monitor`, keep the same searches, schedule the task daily. - **Per manufacturer**: every device a competitor registers, with class, EMDN and certificate; every device they withdraw from the market; every certificate that is suspended, withdrawn or renewed. - **Per risk class and EMDN branch**: new class III vascular implants (`riskClasses: ["class-iii"]`, `emdnCodes: ["P07"]`), new IVDR class D assays, new software devices in a nomenclature branch, restricted to MDR or IVDR if you wish. - **Per product name** or **per UDI-DI**: the devices you distribute or buy, watched for status and certificate changes. The first run delivers every watched device as a `baseline` record, priced as a device like a lookup, so you see what is watched. Later runs deliver only new devices (`added`, priced as a device) and changes (`changed`/`removed`, priced as a change, at most `maxChangesPerRun` per run) with a one-line summary written for an inbox: `Unloader One (05690977326316) – Össur: status On the EU market → No longer placed on the EU market (since 2026-09-10); certificate C-1 Issued → Withdrawn`. Every device of a watched UDI-DI, Basic UDI-DI or manufacturer is read again on each run, because EUDAMED's search does not say whether a device group changed (at most 50,000 devices read again per run); product-name, risk-class and EMDN feeds read their newest pages until a page holds no new device, so a device that has slipped out of that window is not read again. Unchanged devices cost nothing, so a daily watch on a large portfolio costs the start fee when nothing happened. Wording next to a code is not compared, only the code: the labels of risk class, legislation, device status, manufacturer status, certificate type and certificate status, EMDN term names, the manufacturer's country name and notified-body names. Links, version numbers, the last-update date and the two spellings EUDAMED uses for one device status are not compared either. Adding a search to a watch, or changing its `legislation` or `onlyOnTheMarket`, starts a new baseline for the searches affected, charged per device again. #### Sources Two public interfaces of the European Commission, combined: - **API - EUDAMED Public v1.0** on the DG SANTE data lake ([documentation](https://developer.datalake.sante.service.ec.europa.eu/api-details#api=94b9e658-d721-4b58-8d96-022c490f7a17)): the Commission's documented public API, a nightly snapshot of the UDI and actor registers with exact-match filters. Used to resolve UDI-DIs and SRNs in a second. - **The live EUDAMED database** (`ec.europa.eu/tools/eudamed`), through the JSON interface its own web application uses (described by [OpenRegulatory](https://openregulatory.github.io/eudamed-api/)): device search newest-first, device and device-group records, version history, certificates, notified bodies and economic operators. Used for everything the snapshot lacks: details, certificates, today's registrations. It is not documented by the Commission; the Actor validates every response and fails a lookup, uncharged, rather than deliver a half record when the interface changes. Reuse of Commission data is permitted under CC BY 4.0 (Commission Decision 2011/833/EU). Records delivered by this Actor should carry the attribution *Source: EUDAMED, European Commission*. Registration in EUDAMED is a manufacturer's own declaration; certificates are entered by notified bodies; neither replaces a Declaration of Conformity or an EU certificate as evidence. ### Features - **EU medical device lookup by UDI-DI**, Basic UDI-DI, manufacturer SRN, product name, risk class or EMDN code - **Device identification, risk class, legislation and market status** in one record, with `legacyDevice` and special device types - **Manufacturer and authorised representative** with SRN, country and EUDAMED status; the manufacturer record itself is free - **Notified-body certificates** per device group and per manufacturer: number, type, status, issue and expiry dates - **EMDN nomenclature** codes with names, and searches by nomenclature branch - **EUDAMED monitor**: new registrations per class, branch or manufacturer, and status or certificate changes of watched devices, with a webhook - **GS1 check-digit validation** of UDI-DIs before anything is searched - **No personal data**: contact persons, e-mail addresses and telephone numbers that EUDAMED publishes are never read - Runs through the Apify API, on a schedule, or from Make, Zapier and n8n ### Use cases #### Regulatory affairs: competitor and portfolio watch Watch competitor SRNs and your own: new devices, withdrawals, certificate status. A watch on ten manufacturers with 2,000 devices in total costs a baseline of $100 once (the same as looking them up) and then only what changes. #### Distributors and hospital procurement: is this device on the EU market, and who stands behind it? Look up the UDI-DIs on the quotation. `deviceStatus`, `legislation` (MDR or still a legacy directive), `certificates` with expiry and `manufacturer.status` answer the compliance part of a tender in one run; `authorisedRepresentative` names the EU counterpart of a non-EU manufacturer. ```js // npm install apify-client import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor('lwsdjfls/eudamed-device-lookup').call({ udiDis: ['05690977326316', '00733132622610'] }); const { items } = await client.dataset(run.defaultDatasetId).listItems({ clean: true }); for (const { payload } of items) { if (payload.kind !== 'device' || payload.status !== 'found') { console.warn(payload.input, payload.status, payload.statusReason); continue; } const certs = payload.certificates.map((c) => `${c.number} ${c.status} until ${c.expiresOn} (${c.notifiedBody.name})`).join('; '); console.log(`${payload.tradeName} – ${payload.manufacturer.name} (${payload.manufacturer.country}): ${payload.riskClass}, ${payload.legislation}, ${payload.deviceStatus}, registered ${payload.registeredOn}. ${certs || 'no certificate linked'}`); } ``` #### Market analysts: what enters the market A daily feed of new class III vascular implants, or of every new IVDR class D assay, with manufacturer country and notified body: the register as a market signal, months before launch announcements. #### Notified-body and consultancy intelligence Manufacturer records list certificates with their notified body; a watch on manufacturers shows NB switches and certificate renewals as they are entered. ### How to use it 1. Search by what you have. Put device identifiers into **UDI-DIs** or **Basic UDI-DIs**, a manufacturer's registration number into **Manufacturer SRNs**, or a product name into **Product names**. You can also sweep a whole category with **Risk classes** and **EMDN codes**, which is how procurement teams map a market rather than a device. 2. Start with a handful and look at one record. You get the manufacturer, the authorised representative, the device status, the registration date and, when **Include manufacturer certificates** is on, the certificates with their notified body. The `devices` view is the device table and `manufacturers` groups the same data the other way round. 3. Switch **Mode** to `monitor` with a **State key** and a schedule once you want to follow a market instead of check a device. The monitor reports new registrations and status changes in the categories you follow, which is the signal a competitor watch actually needs. A category search can be enormous, so **Maximum devices per search** and **Maximum devices per run** exist to keep a run and its cost predictable. Class and EMDN sweeps produce hundreds of new registrations a day, which is why they are deliberately kept out of the small default input. Two caveats about the source itself, not about this Actor. EUDAMED is still being filled: not every device on the European market is in it yet, so absence is not evidence that a device is unregistered. And the data is what the manufacturer registered, so treat it as the manufacturer's declaration rather than as a verified fact. ```json { "mode": "lookup", "udiDis": ["05690977326316", "00733132622610"], "manufacturerSrns": ["DE-MF-000006413"] } ``` ### Input | Field | What it does | Example | | --- | --- | --- | | `mode` | `lookup` delivers every device on every run; `monitor` delivers a baseline first (charged per device, like a lookup) and later only new devices and changes. | `"lookup"` | | `udiDis` | Device identifiers, one per line: GS1 (14 digits, check-digit validated), HIBCC (`+…`), ICCBBA (`=…`) or IFA. | `["05690977326316", "00733132622610"]` | | `basicUdiDis` | Device group identifiers; every UDI-DI registered under the group is delivered. | `["OSSURTKVNK3ZHP9ZQ"]` | | `manufacturerSrns` | Single Registration Numbers. Delivers the manufacturer record (free) with its certificates, and every device registered under the SRN, newest first. | `["DE-MF-000006413"]` | | `productNames` | Trade-name searches (contains), newest first. | `["Unloader"]` | | `riskClasses` | Newest devices of a risk class (MDR I, IIa, IIb, III; IVDR A, B, C, D). | `["class-iii"]` | | `emdnCodes` | EMDN codes or prefixes (P = implantable prosthetics, P07 = vascular implants and stents). Combined with every product name and risk class above. | `["P07"]` | | `legislation` | Restrict searches to devices registered under one legislation. Changing it on a watch starts a new baseline for its searches. | `"any"` | | `onlyOnTheMarket` | Skip devices marked as no longer placed on the EU market or not intended for it. Changing it on a watch starts a new baseline for its searches. | `false` | | `includeManufacturerCertificates` | Adds the notified-body certificates issued to each manufacturer SRN (up to 300). | `true` | | `maxDevicesPerSearch` | Cap per product name, risk class, EMDN code, Basic UDI-DI or manufacturer, newest first. In monitor mode it must exceed the number of new registrations between two runs. | `100` | | `maxDevicesPerRun` | Caps the charged device records in one run, baseline records included; watched devices read again do not count (at most 50,000 of those per run). | `500` | | `maxChangesPerRun` | Monitor mode: caps the charged changes in one run; changes above the cap are delivered by the next run. | `200` | | `maxConcurrency` | Searches and lookups running at the same time; requests to EUDAMED are paced at 8 per second regardless. | `4` | | `webhookUrl` | Receives a POST with a summary after each run that delivered new devices or changes; a public URL, stored encrypted. | `https://hooks.example.com/eudamed` | | `stateKey` | Separates independent monitors. Defaults to the task ID; a new key starts a new baseline. | `competitors-2026` | ```json { "udiDis": ["05690977326316", "00733132622610"], "manufacturerSrns": ["DE-MF-000006413"], "riskClasses": ["class-iii"], "emdnCodes": ["P07"], "maxDevicesPerSearch": 100 } ``` UDI-DIs are check-digit validated when they are GS1 codes. Searches (product name, risk class, EMDN code, Basic UDI-DI, manufacturer) return the newest devices first, up to `maxDevicesPerSearch` each; `legislation` and `onlyOnTheMarket` narrow every search. EMDN codes combine with every product name and risk class given (class III × P07 = the newest vascular implants and stents); on their own they are a search per code. Monitor mode: ```json { "mode": "monitor", "manufacturerSrns": ["DE-MF-000006413", "IS-MF-000000173"], "riskClasses": ["class-iii"], "emdnCodes": ["P07"], "legislation": "mdr", "maxDevicesPerSearch": 600, "webhookUrl": "https://hooks.example.com/eudamed" } ``` ### Output One record per device (and one per manufacturer). In monitor mode, one record per new device or change with structured `changes` and a `summary`. - `status`: `found`, `not-found`, `invalid-identifier` (wrong GS1 check digit) or `lookup-failed` (EUDAMED did not answer completely; nothing charged) - Identification: `udiDi`, `issuingAgency` (GS1, HIBCC, ICCBBA, IFA), `basicUdiDi`, `tradeName`, `deviceName`, `model`, `reference`, `description` - Classification: `riskClass` (I, IIa, IIb, III; IVDR A–D), `legislation` (MDR, IVDR or a legacy directive) with `legacyDevice`, `specialDeviceType` (software, contact lenses…), `emdn` codes with names, `systemOrProcedurePack` - Status: `deviceStatus` (on the EU market, no longer placed, not intended for the EU), `statusSince`, `registeredOn` (first version), `lastUpdatedOn`, `versionNumber`, `discardedOn`, `placedOnTheMarketIn`, `availableIn` (member states) - Characteristics: `sterile`, `singleUse`, `reusable`, `implantable`, `active`, `measuringFunction`, `latex`, `cmrSubstance` - `manufacturer`: SRN, name, country, EUDAMED status, address; `authorisedRepresentative` for non-EU manufacturers with mandate status - `certificates`: every certificate EUDAMED links to the device group: number, type (MDR QMS, EU technical documentation, legacy MDD Annex II…), status with its EUDAMED code (`statusCode`), issue and expiry dates, and the `notifiedBody` (number and name); `notifiedBodies` as a distinct list - `sourceUrl` to the record in EUDAMED, and `sourceCheckedAt` Manufacturer SRNs additionally deliver a **manufacturer record, free of charge**: name, role, EUDAMED status, country, address, VAT and EORI numbers, website, authorised representatives with mandate dates, the number of registered devices, and the certificates issued to the SRN with their notified bodies. Device details, certificates and searches come from the live database and are as current as EUDAMED itself; UDI-DI resolution uses the Commission's nightly snapshot first and falls back to the live search for devices registered in the last day. ```json { "envelopeVersion": 1, "id": "05690977326316", "scope": "lookup:udi:05690977326316", "changeType": "added", "sourceUrl": "https://ec.europa.eu/tools/eudamed/#/screen/search-device/4ba04706-ea39-4924-9f79-addd38aec119", "scrapedAt": "2026-09-15T14:00:00.000Z", "firstSeenAt": "2026-09-15T14:00:00.000Z", "hash": "e9b54bb6cfb00182cce72bdada41a8497b248f3655b97abdb8eb3d61c3d55d52", "previousHash": null, "changes": [], "summary": "Added: Unloader One® (05690977326316) – Össur Iceland ehf.", "diffText": null, "payload": { "kind": "device", "input": "05690977326316", "inputType": "udi-di", "status": "found", "statusReason": null, "udiDi": "05690977326316", "issuingAgency": "GS1", "basicUdiDi": "5690967BU00037NG", "tradeName": "Unloader One®", "deviceName": null, "model": "BU00037", "reference": "B-241519712", "description": null, "riskClass": "Class I", "riskClassCode": "refdata.risk-class.class-i", "legislation": "MDR (Regulation (EU) 2017/745)", "legislationCode": "refdata.applicable-legislation.mdr", "legacyDevice": false, "specialDeviceType": null, "emdn": [ { "code": "Y061209", "name": "KNEE ORTHOSES" } ], "deviceStatus": "On the EU market", "deviceStatusCode": "refdata.device-model-status.on-the-market", "statusSince": "2026-05-27", "registeredOn": "2026-05-27", "lastUpdatedOn": "2026-05-27", "versionNumber": 1, "basicUdiVersionNumber": 1, "discardedOn": null, "placedOnTheMarketIn": "Netherlands", "availableIn": [ "NL" ], "sterile": false, "singleUse": false, "reusable": false, "implantable": false, "active": false, "measuringFunction": false, "latex": false, "cmrSubstance": false, "systemOrProcedurePack": null, "manufacturer": { "srn": "IS-MF-000000173", "name": "Össur Iceland ehf.", "country": "Iceland", "countryCode": "IS", "status": "Active", "statusCode": "refdata.actor-status.active", "address": "5 Grjótháls 110 Reykjavík" }, "authorisedRepresentative": null, "certificates": [], "notifiedBodies": [], "sourceUrl": "https://ec.europa.eu/tools/eudamed/#/screen/search-device/4ba04706-ea39-4924-9f79-addd38aec119", "sourceCheckedAt": "2026-09-15T14:00:00.000Z" } } ``` ### Pricing | Event | Name | What it means | Price | | --- | --- | --- | --- | | `apify-actor-start` | Actor start | Charged by Apify when a run starts: once for a run of up to 1 GB of memory, and once more for every extra GB. It covers the first five seconds of compute. | $0.00005 per run up to 1 GB of memory ($0.05 per 1,000) | | `device-delivered` **(primary)** | Device delivered | One device (UDI-DI) delivered with identification, manufacturer, authorised representative, risk class, legislation, status, registration date, EMDN code and certificates with notified body. In monitor mode: each device of the first run of a watch (baseline) and each device the watch finds later. | $0.05 per device ($50.00 per 1,000) | | `change-detected` | Change detected | In monitor mode: a device already in your watch whose status, certificates, manufacturer, authorised representative or identification changed, or that disappeared from EUDAMED. At most "Maximum changes per run" per run. | $0.50 per change ($500.00 per 1,000) | The example input above (two UDI-DIs, one manufacturer with its devices, the newest hundred class III vascular implants) costs about $5. A competitor portfolio of 500 devices costs $25 once, in a lookup or as a watch's baseline, and then $0.50 per change, with `maxChangesPerRun` (default 200) as the ceiling of one run. The newest class III devices arrive at some 200 a day across all nomenclature branches ($10 a day); narrow the branch with an EMDN code and the feed costs cents. A watched device whose first lookup failed, or a watched UDI-DI that EUDAMED did not know yet, is priced as a device when it is found, not as a change. A search that suddenly answers without a single device, while the watch knows devices from it, is treated as an outage and not as a withdrawal of everything it holds: the run reports nothing as removed, charges nothing for that search and says in the log which search it was. The same holds for a watched UDI-DI that neither EUDAMED's public API nor its search returns any more: its last known state is kept, and the change is reported once EUDAMED answers again. EUDAMED keeps a withdrawn device with a status rather than deleting it, so a real withdrawal arrives as a `changed` record. Not charged: manufacturer records, devices EUDAMED does not know, invalid identifiers, lookups that failed halfway, and unchanged devices in a watch, including new EUDAMED versions that change nothing a watch compares (links, the last-update date, wording next to a code). ### FAQ #### UDI-DI, Basic UDI-DI, SRN: which identifier do I use? The **UDI-DI** is the identifier on the label of one device model (GS1 GTIN, HIBCC or ICCBBA code). The **Basic UDI-DI** groups models with the same intended purpose and design; certificates refer to it. The **SRN** identifies a manufacturer, authorised representative, importer or producer in EUDAMED (`DE-MF-000006413`). Any of them works; the UDI-DI is the precise one. #### Why does a device I know is on the market come back as not found? Registration is mandatory for devices placed on the market from 28 May 2026; legacy devices already on the market have until November 2026. A device may also be registered under a different issuing agency's format than the one you typed (HIBCC codes start with `+`, ICCBBA with `=`). Try the manufacturer's SRN or the trade name. #### Why is a certificate missing from a device that certainly has one? EUDAMED links certificates to the device group (Basic UDI-DI) only when the notified body entered that scope; the manufacturer record lists every certificate issued to the SRN regardless. Legacy (MDD/IVDD) devices often show no certificate at all, because their certificates predate the Certificates module. #### Can I export a whole risk class? Set `maxDevicesPerSearch` and `maxDevicesPerRun` high enough (class III holds about 165,000 UDI-DIs, at $0.05 each). For anything above a few thousand devices, split by EMDN branch across several runs; requests to EUDAMED are paced at 8 per second. Monitor mode is no cheaper way to export: its baseline costs the same per device. #### Is reusing EUDAMED data legal, and is it GDPR-compliant? The registers are public information published by the European Commission under Regulation (EU) 2017/745 for exactly this transparency purpose, reusable under CC BY 4.0 with attribution. EUDAMED's public actor data includes e-mail addresses, telephone numbers and the names of the persons responsible for regulatory compliance; the Actor does not read those fields, so its records contain no personal data and the GDPR does not apply to the output. It is not affiliated with the European Commission; regulatory conclusions remain yours. ### Related Actors - [ECHA REACH Lookup: SVHC candidate list, Annex XIV and Annex XVII status per substance](https://apify.com/lwsdjfls/echa-reach-svhc-lookup), with the same daily monitor for list additions. - [EU Company ID Resolver for manufacturers and authorised representatives](https://apify.com/lwsdjfls/eu-company-id-resolver): VAT, KvK, KBO, SIREN and LEI with official name and status. ### Support Found a bug or need a feature? Open an issue on the Actor page. We usually respond within a day. # Changelog This Actor's version history is a separate document: https://apify.com/lwsdjfls/eudamed-device-lookup/changelog.md # Actor input Schema ## `mode` (type: `string`): Lookup: every device is delivered on every run with its current record. Monitor: the first run delivers every device as a baseline, charged like a lookup; later runs deliver only new devices and changes for the same searches (schedule it). ## `udiDis` (type: `array`): Device identifiers, one per line: GS1 (14 digits, check-digit validated), HIBCC (+…), ICCBBA (=…) or IFA. ## `basicUdiDis` (type: `array`): Device group identifiers; every UDI-DI registered under the group is delivered. ## `manufacturerSrns` (type: `array`): Single Registration Numbers (XX-MF-000000000). Delivers the manufacturer record (free) with its certificates, and every device registered under the SRN, newest first. ## `productNames` (type: `array`): Trade-name searches (contains). Combine with a risk class, EMDN code or legislation to narrow them; results are newest first. ## `riskClasses` (type: `array`): Newest devices of a risk class (MDR I, IIa, IIb, III; IVDR A, B, C, D). Narrow with EMDN codes or legislation; in monitor mode this is the feed of new registrations in the class. ## `emdnCodes` (type: `array`): European Medical Device Nomenclature codes or prefixes (P = implantable prosthetics, P07 = vascular implants and stents, A060204 = drainage kits). Combined with every product name and risk class above; on their own, a search per code. ## `legislation` (type: `string`): Restrict searches to devices registered under one legislation. In monitor mode, changing it on an existing watch starts a new baseline for its searches, charged per device. ## `onlyOnTheMarket` (type: `boolean`): Skip devices marked as no longer placed on the EU market or not intended for it. In monitor mode, changing it on an existing watch starts a new baseline for its searches, charged per device. ## `includeManufacturerCertificates` (type: `boolean`): Adds the notified-body certificates issued to each manufacturer SRN (up to 300) to the manufacturer record. ## `maxDevicesPerSearch` (type: `integer`): Cap per product name, risk class, EMDN code, Basic UDI-DI or manufacturer, newest first. In monitor mode it must exceed the number of new registrations between two runs (class III gains a few hundred a day). ## `maxDevicesPerRun` (type: `integer`): Caps the charged device records in one run, baseline records of a monitor included. Watched devices read again do not count; at most 50,000 of those are read per run. ## `maxChangesPerRun` (type: `integer`): Monitor mode: caps the charged changes ($0.50 each) in one run. Changes above the cap are not lost; the next run delivers them. ## `maxConcurrency` (type: `integer`): Searches and lookups running at the same time. Requests to EUDAMED are paced at 8 per second regardless. ## `webhookUrl` (type: `string`): Receives a POST with a summary after each run that delivered new devices or changes. Must be a public http(s) address; redirects are not followed. Stored encrypted, because webhook URLs often carry a token. ## `stateKey` (type: `string`): Separates independent monitors. Defaults to the task ID, so each saved task keeps its own baseline; a new key starts a new baseline, charged per device. ## Actor input object example ```json { "mode": "lookup", "udiDis": [ "05690977326316", "00733132622610" ], "basicUdiDis": [], "manufacturerSrns": [ "DE-MF-000006413" ], "productNames": [], "riskClasses": [], "emdnCodes": [], "legislation": "any", "onlyOnTheMarket": false, "includeManufacturerCertificates": true, "maxDevicesPerSearch": 100, "maxDevicesPerRun": 500, "maxChangesPerRun": 200, "maxConcurrency": 4, "webhookUrl": "https://hooks.example.com/eudamed", "stateKey": "competitors-2026" } ``` # Actor output Schema ## `devices` (type: `string`): Device records: UDI-DI, manufacturer, risk class, status, registration date, certificates. ## `changes` (type: `string`): Monitor mode: new devices and changes on the watched searches. ## `manufacturers` (type: `string`): Manufacturer records with status, authorised representatives and certificates. ## `runSummary` (type: `string`): Counts, failures and the cost of the run. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "udiDis": [ "05690977326316", "00733132622610" ], "manufacturerSrns": [ "DE-MF-000006413" ] }; // Run the Actor and wait for it to finish const run = await client.actor("lwsdjfls/eudamed-device-lookup").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "udiDis": [ "05690977326316", "00733132622610", ], "manufacturerSrns": ["DE-MF-000006413"], } # Run the Actor and wait for it to finish run = client.actor("lwsdjfls/eudamed-device-lookup").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "udiDis": [ "05690977326316", "00733132622610" ], "manufacturerSrns": [ "DE-MF-000006413" ] }' | apify call lwsdjfls/eudamed-device-lookup --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,lwsdjfls/eudamed-device-lookup" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/jT3Rcybr6HlmYMQP8/builds/m3maofd2tRA0bLINu/openapi.json