# EUDAMED Devices & UDI Registry Scraper (`automation-lab/eudamed-devices-udi-registry-scraper`) Actor

🔎 Search and export public EUDAMED device and UDI registry records by identifiers, manufacturer, model, risk class, and status for EU compliance and market research.

- **URL**: https://apify.com/automation-lab/eudamed-devices-udi-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## EUDAMED Devices & UDI Registry Scraper

Search and export public medical-device records from the European Commission's **EUDAMED Device and UDI registry**.

Turn UDI-DIs, manufacturer names, SRNs, product models, trade names, risk classes, EMDN codes, and status filters into a clean dataset ready for compliance work, market research, and monitoring.

No EUDAMED login or private credentials are required for the public device scope.

### What does EUDAMED Devices & UDI Registry Scraper do?

The Actor queries the public EUDAMED device-search service and saves normalized device rows to an Apify dataset.

It can:

- 🔎 look up a specific UDI-DI or Basic UDI-DI;
- 🏭 find devices associated with a manufacturer name or SRN;
- 🏥 search by device name, model, trade name, or reference;
- ⚖️ narrow results with legislation, scope, type, risk class, EMDN, and status codes;
- 📚 attach public version-history metadata;
- 📄 paginate through larger result sets;
- 📤 export records as JSON, CSV, Excel, XML, or RSS.

### Who is it for?

#### Regulatory affairs and quality teams

Verify public registrations, compare identifiers, and prepare repeatable evidence for internal device files.

#### Medical-device manufacturers

Review how products and competitors appear in the public EU registry and check manufacturer identifiers.

#### Distributors and procurement teams

Confirm manufacturer, device status, UDI, and risk-class data before onboarding products.

#### Compliance consultants

Build reusable client checks without manually copying rows from the EUDAMED interface.

#### Market-intelligence analysts

Create structured lists of devices and manufacturers for segmentation, product research, and change tracking.

### Why use this EUDAMED scraper?

Manual EUDAMED searches are useful for one-off checks, but repetitive research quickly becomes slow and difficult to reproduce.

This Actor provides:

- structured fields instead of copied table cells;
- deterministic filters that can be saved and rerun;
- pagination and result limits;
- machine-readable reference codes;
- readable labels for common status and risk-class codes;
- direct Apify API, webhook, schedule, and integration support;
- normalized timestamps and source links for traceability.

### What data can you extract?

| Field | Description |
|---|---|
| `primaryDi` | Primary UDI-DI |
| `basicUdi` | Basic UDI-DI family identifier |
| `uuid` | EUDAMED UUID |
| `ulid` | EUDAMED ULID |
| `basicUdiUlid` | Linked Basic UDI record identifier |
| `tradeName` | Registered trade name |
| `deviceName` | Registered device name |
| `deviceModel` | Device model |
| `reference` | Manufacturer or registry reference |
| `riskClassCode` | Original EUDAMED risk-class code |
| `riskClass` | Human-readable risk class |
| `deviceStatusCode` | Original device-status code |
| `deviceStatus` | Human-readable device status |
| `manufacturerName` | Legal manufacturer name |
| `manufacturerSrn` | Manufacturer Single Registration Number |
| `manufacturerStatus` | Human-readable manufacturer status |
| `authorisedRepresentativeName` | EU authorised representative, when available |
| `authorisedRepresentativeSrn` | Representative SRN, when available |
| `versionNumber` | Registry version number |
| `latestVersion` | Whether this is the latest version |
| `versions` | Optional public version-history metadata |
| `scrapedAt` | UTC extraction timestamp |

### How to scrape EUDAMED device records

1. Open the Actor input page.
2. Enter one or more device, manufacturer, or classification filters.
3. Set a small `maxItems` value for the first run.
4. Enable version history only when you need it.
5. Click **Start**.
6. Open the **Dataset** tab to inspect results.
7. Export the dataset or connect it to your workflow.

The prefilled `pacemaker` model search is a low-cost smoke test.

### Input options

#### Device identifiers

- `primaryDi` — exact or partial primary UDI-DI supported by EUDAMED.
- `basicUdi` — Basic UDI-DI family identifier.
- `reference` — manufacturer or registry reference.

#### Names and models

- `deviceName` — registered medical-device name.
- `deviceModel` — model or model keyword.
- `tradeName` — commercial trade name.

#### Manufacturer filters

- `manufacturerName` — legal manufacturer name or keyword.
- `manufacturerSrn` — EUDAMED manufacturer SRN.

#### Classification filters

- `legislationCode` — applicable EUDAMED legislation code.
- `deviceScopeCode` — device-scope reference code.
- `deviceTypeCode` — device-type reference code.
- `riskClassCode` — full risk-class code.
- `emdnCode` — European Medical Device Nomenclature code.
- `statusCode` — full device-status code.

#### Limits and paging

- `maxItems` — maximum unique device rows to save.
- `pageSize` — records requested per source page, from 1 to 300.
- `startPage` — zero-based page for resumable exports.
- `language` — two-letter EUDAMED language code.
- `includeHistoricalVersions` — attach public version metadata.
- `additionalFilters` — advanced official API query parameters.

### Input example

```json
{
  "deviceModel": "pacemaker",
  "statusCode": "refdata.device-model-status.on-the-market",
  "includeHistoricalVersions": false,
  "maxItems": 25,
  "pageSize": 25,
  "language": "en"
}
````

For a manufacturer lookup:

```json
{
  "manufacturerSrn": "IT-MF-000025272",
  "maxItems": 100
}
```

### Output example

```json
{
  "source": "EUDAMED",
  "sourceUrl": "https://ec.europa.eu/tools/eudamed/#/screen/search-device",
  "primaryDi": "D-899565UN",
  "basicUdi": "B-899565UN",
  "uuid": "f4cf4775-10c5-40f9-b1bf-fabfd8fdfe36",
  "riskClassCode": "refdata.risk-class.class-iia",
  "riskClass": "Class Iia",
  "deviceStatus": "On The Market",
  "manufacturerName": "MED ITALIA BIOMEDICA S.R.L",
  "manufacturerSrn": "IT-MF-000025272",
  "versionNumber": 1,
  "latestVersion": true,
  "reference": "899565",
  "scrapedAt": "2026-07-14T00:00:00.000Z"
}
```

A source field can legitimately be `null` when EUDAMED does not publish it on the matching search row.

### How much does it cost to scrape EUDAMED devices?

This Actor uses pay-per-event pricing: a **$0.005 start fee** plus one charge per saved device.

| Apify tier | Price per device | Approx. 1,000 devices incl. start |
|---|---:|---:|
| Free | $0.00017037 | $0.1754 |
| Bronze | $0.00014815 | $0.1532 |
| Silver | $0.00011556 | $0.1206 |
| Gold | $0.000088891 | $0.0939 |
| Platinum | $0.000059261 | $0.0643 |
| Diamond | $0.000041483 | $0.0465 |

You pay for produced records rather than a monthly data subscription. Platform compute is covered by the pay-per-event price. The final run cost is visible in the Apify Console.

Use a low `maxItems` value to validate your filters before a larger export.

### Pagination and large exports

EUDAMED uses zero-based result pages.

The Actor automatically advances pages until it reaches `maxItems` or the final source page. It deduplicates rows by UDI-DI and version number.

For resumable jobs:

1. choose a fixed `pageSize`;
2. run from `startPage: 0`;
3. record the last completed page;
4. resume with a later `startPage`;
5. merge datasets using UDI-DI plus version number.

Source records can change between runs, so a stable identifier is better than relying on row order.

### Historical versions

Set `includeHistoricalVersions` to `true` to call the public EUDAMED versions endpoint for every device.

The `versions` array may include:

- version UUID and ULID;
- version number;
- latest-version flag;
- version state code;
- last-update date.

Version lookup adds one request per device. Leave it disabled for broad discovery when current rows are sufficient.

### Tips for reliable EUDAMED searches

- Start with one strong identifier whenever possible.
- Use the full SRN for manufacturer verification.
- Preserve reference codes from previous output for precise reruns.
- Keep the first test to 10–25 records.
- Avoid combining unrelated filters that cannot match the same row.
- Use official full status and risk-class codes.
- Schedule recurring searches with identical input for change detection.
- Compare `primaryDi`, `versionNumber`, and `lastUpdateDate` between snapshots.

### Data quality and limitations

The Actor returns data published by the European Commission's public EUDAMED service.

Keep in mind:

- not every field is populated for every device;
- some fields depend on the applicable legislation and record type;
- public EUDAMED coverage evolves as modules and registration obligations change;
- readable labels are derived from official reference codes;
- version history contains metadata exposed by the public version endpoint;
- EUDAMED source availability and behavior can change without notice.

The Actor does not certify a device, assess conformity, or replace professional regulatory advice.

### Scheduling and monitoring

Apify schedules can rerun an input hourly, daily, weekly, or monthly.

A practical monitoring workflow is:

1. save a manufacturer, model, or UDI search as a task;
2. schedule the task;
3. send each dataset to a webhook or storage system;
4. compare stable identifiers and version fields;
5. notify a compliance owner when status or version changes.

For sparse checks, a small scheduled lookup can be more useful than repeatedly exporting a full registry segment.

### Integrations

#### Google Sheets

Send normalized rows to a sheet used by regulatory or procurement teams.

#### Slack or Microsoft Teams

Post a message when a scheduled device lookup returns a new status or version.

#### Make and Zapier

Trigger downstream enrichment, approval, or ticket workflows after each run.

#### Webhooks

Subscribe to run completion and fetch the default dataset through its API URL.

#### Data warehouses

Export JSON or CSV to BigQuery, Snowflake, PostgreSQL, or an object-storage pipeline.

### Use with the Apify API — JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/eudamed-devices-udi-registry-scraper').call({
  deviceModel: 'pacemaker',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with the Apify API — Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/eudamed-devices-udi-registry-scraper').call(
    run_input={'manufacturerName': 'MED ITALIA', 'maxItems': 50}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with the Apify API — cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~eudamed-devices-udi-registry-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"primaryDi":"D-899565UN","maxItems":10}'
```

Fetch results using the `defaultDatasetId` returned by the completed run.

### Use EUDAMED data with MCP

Connect the Actor through this Apify MCP endpoint:

`https://mcp.apify.com/?tools=automation-lab/eudamed-devices-udi-registry-scraper`

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/eudamed-devices-udi-registry-scraper"
```

Provide your Apify token securely when prompted, then ask Claude to run the Actor with structured input.

#### Claude Desktop setup

Add the server to Claude Desktop's MCP configuration:

```json
{
  "mcpServers": {
    "apify-eudamed": {
      "url": "https://mcp.apify.com/?tools=automation-lab/eudamed-devices-udi-registry-scraper"
    }
  }
}
```

#### Cursor setup

Open **Settings → MCP**, add a remote HTTP server, and use the same `apify-eudamed` name and MCP URL. Cursor also accepts the `mcpServers` JSON shown above.

#### VS Code setup

Open the MCP server configuration in VS Code, choose an HTTP server, and add the same Apify MCP URL. Store credentials in VS Code's secure input flow rather than committing them.

Example prompts:

- “Find 20 public EUDAMED devices matching the model pacemaker and group them by manufacturer.”
- “Look up this UDI-DI and summarize its manufacturer, risk class, and status.”
- “Compare version metadata for devices associated with this manufacturer SRN.”

### Is it legal to scrape EUDAMED?

EUDAMED provides a public search surface for public device information. This Actor accesses that anonymous public scope.

You remain responsible for:

- your lawful purpose and jurisdiction;
- compliance with applicable terms and database rights;
- responsible request volume;
- secure handling of exported data;
- validating information before regulated decisions.

No login-only or private EUDAMED data is accessed.

### Frequently asked questions

#### Do I need an EUDAMED account?

No. The Actor is designed for the anonymous public device-search scope.

#### Can I search by UDI-DI?

Yes. Use `primaryDi` or `basicUdi` depending on the identifier you have.

#### Can I search by manufacturer?

Yes. Use `manufacturerName` for text search or `manufacturerSrn` for a registry identifier.

#### Does it include certificates?

No. This Actor focuses on device and UDI registry rows. Use the related EUDAMED certificates actor for certificates.

#### Why are some output values null?

EUDAMED search rows do not populate every field for every record. Null means the public source did not supply that field on the result.

#### Why did my search return no records?

Check for incompatible filters, remove optional criteria, verify full reference codes, and try one identifier or model keyword first.

#### Why did a run fail with an HTTP error?

The European Commission service may be temporarily unavailable or filter a request. The Actor retries transient failures; rerun later if the final retry still fails.

#### How do I monitor changes?

Save the input as an Apify task, schedule it, and compare UDI-DI, version, status, and update fields between datasets.

### Related scrapers

- [EUDAMED Certificates Scraper](https://apify.com/automation-lab/eudamed-certificates-scraper) — export public EUDAMED certificate records.
- [OpenFDA 510(k) Device Clearances Scraper](https://apify.com/automation-lab/openfda-510k-device-clearances-scraper) — research US device clearances.
- [OpenFDA Device Classification Scraper](https://apify.com/automation-lab/openfda-device-classification-scraper) — retrieve FDA classification records.

### Support

If a valid public EUDAMED search behaves differently in this Actor, open an issue from the Actor page and include:

- the input with sensitive data removed;
- the run URL;
- the expected registry result;
- the observed output or error.

That evidence helps reproduce source changes quickly.

# Actor input Schema

## `primaryDi` (type: `string`):

Primary device identifier (UDI-DI), exact or partial as supported by EUDAMED.

## `basicUdi` (type: `string`):

Basic UDI-DI family identifier.

## `reference` (type: `string`):

Manufacturer or registry reference number.

## `deviceName` (type: `string`):

Search text from the registered device name.

## `deviceModel` (type: `string`):

Model name or keyword. The prefill returns public records without login.

## `tradeName` (type: `string`):

Registered product or trade name.

## `manufacturerName` (type: `string`):

Legal manufacturer name or keyword.

## `manufacturerSrn` (type: `string`):

EUDAMED Single Registration Number, for example IT-MF-000025272.

## `legislationCode` (type: `string`):

EUDAMED applicable-legislation reference code (for example MDR or IVDR code).

## `deviceScopeCode` (type: `string`):

EUDAMED device scope reference code.

## `deviceTypeCode` (type: `string`):

EUDAMED device type reference code.

## `riskClassCode` (type: `string`):

Full EUDAMED risk-class code, such as refdata.risk-class.class-iia.

## `emdnCode` (type: `string`):

European Medical Device Nomenclature code.

## `statusCode` (type: `string`):

Full EUDAMED device status reference code, such as refdata.device-model-status.on-the-market.

## `includeHistoricalVersions` (type: `boolean`):

Fetch the public EUDAMED version metadata for every returned device.

## `maxItems` (type: `integer`):

Maximum unique device rows to save.

## `pageSize` (type: `integer`):

Records requested per EUDAMED page (1–300).

## `startPage` (type: `integer`):

Zero-based EUDAMED result page for resumable exports.

## `language` (type: `string`):

Two-letter language code used for EUDAMED labels.

## `additionalFilters` (type: `object`):

Optional key/value query parameters for advanced EUDAMED API filters not listed above.

## Actor input object example

```json
{
  "deviceModel": "pacemaker",
  "includeHistoricalVersions": false,
  "maxItems": 10,
  "pageSize": 20,
  "startPage": 0,
  "language": "en",
  "additionalFilters": {}
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "deviceModel": "pacemaker",
    "includeHistoricalVersions": false,
    "maxItems": 10,
    "pageSize": 20,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/eudamed-devices-udi-registry-scraper").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "deviceModel": "pacemaker",
    "includeHistoricalVersions": False,
    "maxItems": 10,
    "pageSize": 20,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/eudamed-devices-udi-registry-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "deviceModel": "pacemaker",
  "includeHistoricalVersions": false,
  "maxItems": 10,
  "pageSize": 20,
  "language": "en"
}' |
apify call automation-lab/eudamed-devices-udi-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/eudamed-devices-udi-registry-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EUDAMED Devices & UDI Registry Scraper",
        "description": "🔎 Search and export public EUDAMED device and UDI registry records by identifiers, manufacturer, model, risk class, and status for EU compliance and market research.",
        "version": "0.1",
        "x-build-id": "HHIcQT1yKgAuRMMHL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~eudamed-devices-udi-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-eudamed-devices-udi-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~eudamed-devices-udi-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-eudamed-devices-udi-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~eudamed-devices-udi-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-eudamed-devices-udi-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "primaryDi": {
                        "title": "UDI-DI",
                        "type": "string",
                        "description": "Primary device identifier (UDI-DI), exact or partial as supported by EUDAMED."
                    },
                    "basicUdi": {
                        "title": "Basic UDI-DI",
                        "type": "string",
                        "description": "Basic UDI-DI family identifier."
                    },
                    "reference": {
                        "title": "Reference",
                        "type": "string",
                        "description": "Manufacturer or registry reference number."
                    },
                    "deviceName": {
                        "title": "Device name",
                        "type": "string",
                        "description": "Search text from the registered device name."
                    },
                    "deviceModel": {
                        "title": "Device model",
                        "type": "string",
                        "description": "Model name or keyword. The prefill returns public records without login."
                    },
                    "tradeName": {
                        "title": "Trade name",
                        "type": "string",
                        "description": "Registered product or trade name."
                    },
                    "manufacturerName": {
                        "title": "Manufacturer name",
                        "type": "string",
                        "description": "Legal manufacturer name or keyword."
                    },
                    "manufacturerSrn": {
                        "title": "Manufacturer SRN",
                        "type": "string",
                        "description": "EUDAMED Single Registration Number, for example IT-MF-000025272."
                    },
                    "legislationCode": {
                        "title": "Legislation code",
                        "type": "string",
                        "description": "EUDAMED applicable-legislation reference code (for example MDR or IVDR code)."
                    },
                    "deviceScopeCode": {
                        "title": "Device scope code",
                        "type": "string",
                        "description": "EUDAMED device scope reference code."
                    },
                    "deviceTypeCode": {
                        "title": "Device type code",
                        "type": "string",
                        "description": "EUDAMED device type reference code."
                    },
                    "riskClassCode": {
                        "title": "Risk class code",
                        "type": "string",
                        "description": "Full EUDAMED risk-class code, such as refdata.risk-class.class-iia."
                    },
                    "emdnCode": {
                        "title": "EMDN code",
                        "type": "string",
                        "description": "European Medical Device Nomenclature code."
                    },
                    "statusCode": {
                        "title": "Device status code",
                        "type": "string",
                        "description": "Full EUDAMED device status reference code, such as refdata.device-model-status.on-the-market."
                    },
                    "includeHistoricalVersions": {
                        "title": "Include version history",
                        "type": "boolean",
                        "description": "Fetch the public EUDAMED version metadata for every returned device.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum devices",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum unique device rows to save.",
                        "default": 25
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Records requested per EUDAMED page (1–300).",
                        "default": 100
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Zero-based EUDAMED result page for resumable exports.",
                        "default": 0
                    },
                    "language": {
                        "title": "Language",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter language code used for EUDAMED labels.",
                        "default": "en"
                    },
                    "additionalFilters": {
                        "title": "Additional EUDAMED filters",
                        "type": "object",
                        "description": "Optional key/value query parameters for advanced EUDAMED API filters not listed above.",
                        "default": {}
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```