# Medical Device Manufacturer Data — FDA Registrations (`foxlabs/fda-device-manufacturer-data`) Actor

Look up medical device manufacturers, importers and contract sterilizers in the FDA establishment registration database by firm name. Returns registration and FEI numbers, facility address, operations performed, device classes, product codes and 510(k)/PMA numbers.

- **URL**: https://apify.com/foxlabs/fda-device-manufacturer-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 company records

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Medical Device Manufacturer Data — FDA Registrations 🩺

**foXLabs US registry-data series:** [US Healthcare Organizations (NPI)](https://apify.com/foxlabs/npi-healthcare-organization-data) · [Pharma Companies (Drugs@FDA)](https://apify.com/foxlabs/fda-drug-sponsor-data)

🎉 Turn the FDA Device Registration & Listing system into clean, structured manufacturer data — no login, no API key, one row per registered establishment.
Built for medical-device supply-chain & sourcing, regulatory / quality intelligence, competitive analysts and B2B sellers into device makers.

### 🔍 What is the Medical Device Manufacturer Data — and when should you use it?

Give this actor a manufacturer name (`Medtronic`), an FDA registration number or an FEI number and it returns the matching registered establishments — firm name, registration + FEI numbers, owner/operator, status and expiry, address, device classes, product codes, **brand (proprietary) names**, **510(k)/PMA clearance numbers**, listing count and importer flag — as clean rows.

**Use it when you need:** every FDA-registered establishment for a manufacturer; the device classes, product codes and clearances a firm holds; or resolving a registration/FEI number to its establishment.

**Use something else when:** you need drug approvals (use the [Drugs@FDA actor](https://apify.com/foxlabs/fda-drug-sponsor-data)) or a healthcare provider (use the [NPI actor](https://apify.com/foxlabs/npi-healthcare-organization-data)).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/fda-device-manufacturer-data`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered record, never for errors.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want to pull data using the Apify Actor `foxlabs/fda-device-manufacturer-data`.

Input: `queries` is a list of manufacturer names, FDA registration numbers or FEI numbers. `maxResultsPerQuery` caps rows per query (default 50).

Start with:
{ "queries": ["Medtronic"], "maxResultsPerQuery": 25 }

Ask me what to look up, run the Actor, then summarise the rows as a table.
```

Things you can ask your agent for:

- "List every FDA-registered Medtronic establishment with its device classes."
- "What 510(k)/PMA clearances does Boston Scientific hold?"
- "Resolve this FEI number to its establishment and status."

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/fda-device-manufacturer-data.md`.

### 📋 Overview

Everything you need to turn FDA Device Registration & Listing — the FDA’s official openFDA API, keyless into clean, structured data — in one actor, with no login, cookies or API key.

**Why teams pick this actor:**

- ✅ **Whole establishment profile, one call** — name/number in; registration, devices and clearances out.
- 🏷️ **Brand names recovered** — proprietary (brand) names read from the correct record field (e.g. Medtronic → Affinity, ECMO, Minimax).
- 📄 **Clearance ids** — 510(k)/PMA numbers from the record root, filled for most establishments.
- 🧭 **Device classes + product codes** — regulatory class and product-code detail on every row.
- 💰 **Pay only for results** — per-row pricing, empty/failed lookups never billed.
- 🤖 **Agent-ready** — MCP + x402 agentic payments.

### ✨ Features

- 🔍 **Name / registration / FEI search** — one input, three ways in.
- 🏭 **Establishment profile** — firm name, owner/operator, status, expiry, importer flag, address.
- 🩺 **Device detail** — device classes, product codes (with regulation number + specialty), listing count.
- 📄 **Clearances + brands** — 510(k)/PMA numbers and proprietary brand names.
- 📦 **Clean export** — deduplicated camelCase rows, ready for CSV/Excel/JSON.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~fda-device-manufacturer-data/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "queries": ["Medtronic"], "maxResultsPerQuery": 25 }'
```

### 🚀 Getting Started (3 steps)

1. **Choose your targets** — manufacturer names (`Medtronic`, `Abbott`), registration numbers or FEI numbers.
2. **Set the cap** — `maxResultsPerQuery` limits rows per query (default 50).
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

```json
{
  "queries": ["Medtronic", "Boston Scientific"],
  "maxResultsPerQuery": 50
}
```

| Field | Type | Description |
|---|---|---|
| `queries` | array | Manufacturer names, FDA registration numbers or FEI numbers. |
| `maxResultsPerQuery` | integer | Caps rows per query (default 50, max 100 per openFDA). |
| `maxConcurrency` | integer | How many queries to fetch at once (default 4). |
| `includeRaw` | boolean | Attach the source’s untouched record under `raw`. |

### 📤 Output

One row per record, saved to the dataset. Every row also carries `query`, `scrapedAt`, and — when a lookup fails — an `error` explaining why (never silently dropped, never billed).

| Field | Type | Description |
|---|---|---|
| `companyName` | string | Establishment / firm name |
| `registrationNumber` | string | FDA registration number — the join key |
| `feiNumber` | string | FDA Establishment Identifier |
| `ownerOperator` | string | Owner / operator firm (+ number) |
| `status` | string | `active` / `inactive`, from the registration status |
| `registrationExpiresOn` | string | Registration expiry (year-end) |
| `address` / `city` / `postalCode` / `countryName` | string | Establishment (site) location |
| `ownerAddress` | string | Owner/operator corporate (HQ) contact address |
| `deviceClasses` | array | FDA device class(es) across listed products |
| `productCodes` | array | Product code + device name, specialty, regulation number |
| `clearanceNumbers` | array | 510(k) / PMA clearance ids |
| `proprietaryNames` | array | Brand / proprietary device names |
| `listingCount` | integer | Number of listed products |
| `isInitialImporter` | boolean | Whether the firm is an initial importer |
| `createdOn` | string | Earliest listing creation date (ISO) |
| `sourceUrl` | string | Public accessdata.fda.gov registration URL |

```json
{
  "companyName": "Medtronic …",
  "registrationNumber": "…",
  "feiNumber": "…",
  "deviceClasses": ["2"],
  "productCodes": [{ "code": "…", "device": "…" }],
  "clearanceNumbers": ["K000430"],
  "proprietaryNames": ["Affinity", "ECMO", "Minimax"],
  "createdOn": "2008-03-14",
  "sourceUrl": "https://www.accessdata.fda.gov/…"
}
```

### 💼 Use cases

**1. Supplier / manufacturer sourcing** — find and qualify device makers by name, class and location.
*Input:* manufacturer names in `queries`. *Output:* establishments + device classes + status. *Use:* shortlist qualified, FDA-registered suppliers.

**2. Regulatory / quality intelligence** — see a firm’s registrations, clearances and product codes.
*Input:* names or registration/FEI numbers. *Output:* clearances + product codes + expiry. *Use:* track a competitor’s regulatory footprint.

**3. Import due diligence** — verify a foreign manufacturer’s FDA registration.
*Input:* FEI or registration numbers. *Output:* exact establishment records. *Use:* confirm status before importing.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/fda-device-manufacturer-data').call({ "queries": ["Medtronic"], "maxResultsPerQuery": 25 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/fda-device-manufacturer-data').call(run_input={ "queries": ["Medtronic"], "maxResultsPerQuery": 25 })
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the actor API with your `queries` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay-per-event: **$0.002 per delivered record**. Empty or failed lookups are never billed. Bulk queries scale linearly; you pay for the rows you actually get. [View current pricing.](https://apify.com/foxlabs/fda-device-manufacturer-data)

### ❓ FAQ

**Do I need an FDA account, login or API key?** No. This reads the public openFDA device registration & listing API.

**What do I search by?** A manufacturer name, an FDA registration number or an FEI number.

**Do rows include brand names and clearances?** Yes — proprietary (brand) names and 510(k)/PMA clearance numbers are included where the establishment carries them.

**Why is there no phone or headcount?** FDA device registration carries no firmographics; we don’t ship empty columns. Pair with a firmographic actor from Fox Labs.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting

- **Fewer rows than expected** — openFDA caps a single query at 100; split large manufacturers or raise the cap toward 100.
- **No clearances on a row** — not every establishment has a linked 510(k)/PMA; the field is present when the source lists one.
- **No rows for a name** — try the legal firm name, the owner/operator name, or the registration/FEI number.

### ⚠️ Trademark

Independent tool built on the public openFDA device registration dataset. Not affiliated with or endorsed by the FDA or any named manufacturer. Company and product names belong to their owners and are used for identification only.

### ⚖️ Is it legal to scrape this data?

This actor reads public device-registration records (business data) from an official US government API published for public use. Results can still contain personal data (e.g. an official’s name); personal data is protected by the GDPR and similar laws, so only process it with a legitimate basis. See Apify’s blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor’s **Issues** tab
- 🧠 **More clean B2B data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.3 — 2026-09-06

- **Added the owner/operator corporate address.** New `ownerAddress` field carries the firm’s corporate contact address (the HQ), distinct from the establishment address — filled on effectively every record. Recovered from `owner_operator.contact_address`, which the earlier version ignored.

#### 0.2 — 2026-09-06

- **Recovered brand names.** `proprietaryNames` read a per-product field that does not exist on this endpoint; the proprietary-name array lives at the record root. Now populated (e.g. Medtronic → Affinity, ECMO, Minimax, Intersept).
- **Recovered clearance numbers.** `clearanceNumbers` previously read only the per-product openFDA arrays (~5% fill). The primary 510(k)/PMA id sits on the record root — now included, so most establishments carry their clearance id.
- **Fixed the listing date.** `createdOn` mapped a PMA number to a date (always empty). It now uses the earliest product `created_date` — a real date, present on every listing.
- **Removed a dead column.** `operations` (from `establishment_type`) is `[null]` across the dataset — dropped rather than shipped empty.
- **Dropped empty-promise columns.** Removed firmographic template fields FDA device registration never carries (`taxNumber, legalForm, incorporatedOn, dissolvedOn, industryCode, employees, capital, website, email, phone, officers`).
- **Output schema linked** in `actor.json` so the Store renders the Output tab.

#### 0.1

- Initial release: device manufacturer / establishment lookup from FDA Device Registration & Listing by firm name, registration number or FEI number. Returns owner/operator, registration status + expiry, device classes, product codes, listing count and importer flag.

# Actor input Schema

## `queries` (type: `array`):

Firm names (`Medtronic`, `Siemens Healthineers`) or FDA registration / FEI numbers. Names are searched across owner-operator and establishment names.

## `maxResultsPerQuery` (type: `integer`):

How many rows a single query may produce.

## `maxConcurrency` (type: `integer`):

How many queries to run at the same time. Lower it if the source throttles you.

## `includeRaw` (type: `boolean`):

Attach the source's untouched response under `raw`. Useful when you need a field this actor does not map.

## `requestDelayMs` (type: `integer`):

Politeness delay against a public source. Raise it for large runs.

## `proxyConfiguration` (type: `object`):

Optional. openFDA is an open API and rarely needs a proxy.

## Actor input object example

```json
{
  "queries": [
    "Medtronic",
    "Abbott",
    "Siemens Healthineers",
    "Boston Scientific"
  ],
  "maxResultsPerQuery": 10,
  "maxConcurrency": 4,
  "includeRaw": false,
  "requestDelayMs": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "queries": [
        "Medtronic",
        "Abbott",
        "Siemens Healthineers",
        "Boston Scientific"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/fda-device-manufacturer-data").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 = { "queries": [
        "Medtronic",
        "Abbott",
        "Siemens Healthineers",
        "Boston Scientific",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/fda-device-manufacturer-data").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 '{
  "queries": [
    "Medtronic",
    "Abbott",
    "Siemens Healthineers",
    "Boston Scientific"
  ]
}' |
apify call foxlabs/fda-device-manufacturer-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/fda-device-manufacturer-data"
        }
    }
}

```

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 <APIFY_API_TOKEN>` 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/ZoOaRSLFUZh3uGfmc/builds/6m99WC3IlNFHzAwSX/openapi.json