# FDA Medical Device Establishment Registration Scraper (`compute-edge/fda-device-registrations-scraper`) Actor

Extract FDA-registered medical device manufacturers and establishments from openFDA. Get firm names, addresses, FEI and registration numbers, establishment types, product codes, device names, and medical specialties. Filter by state, country, firm name, or product code.

- **URL**: https://apify.com/compute-edge/fda-device-registrations-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## FDA Medical Device Establishment Registration Scraper

Extract structured establishment and manufacturer data from the **openFDA Device Registration & Listing database** — the authoritative source for FDA-registered medical device manufacturers, importers, and contract manufacturers. This Actor fetches device establishment registrations and provides powerful filtering by state, country, firm name, and product code.

The openFDA Device Registration & Listing data is maintained by the U.S. Food and Drug Administration (FDA) as the official registry of all establishments that manufacture, import, or contract-manufacture medical devices for the U.S. market. Regulatory professionals, quality assurance teams, procurement specialists, and business development professionals rely on this data for supply chain verification, competitive intelligence, and product sourcing.

### Key Features

- **Complete device establishment registration extraction** — Access FDA-registered manufacturers, importers, repackagers, and distributors
- **State filtering** — Narrow results to specific US states (e.g., "CA", "TX", "NY")
- **Country filtering** — Filter by ISO country codes (e.g., "US", "DE", "JP")
- **Firm name search** — Case-insensitive partial matching on establishment names
- **Product code filtering** — Isolate establishments by FDA device classification product codes (e.g., "MQP", "LLL")
- **Comprehensive product data** — Extract product codes, device names, medical specialty classifications, and regulatory information
- **Contact information** — Owner/operator firm names and regulatory correspondent contact details
- **No authentication required** — Free public openFDA API, no credentials needed
- **Batch-optimized output** — Clean JSON ready for supply chain analysis, RAG pipelines, or business intelligence platforms

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `firmName` | string | Establishment name (manufacturer, importer, etc.) |
| `registrationNumber` | string | FDA registration number for this establishment |
| `feiNumber` | string | Facility Establishment Identifier (FEI) number |
| `establishmentType` | string | Establishment type(s), e.g., "Manufacturer; Importer" |
| `addressLine1` | string | Street address (line 1) |
| `addressLine2` | string | Street address (line 2, if applicable) |
| `city` | string | City name |
| `stateCode` | string | US state code (2-letter) or province |
| `countryCode` | string | ISO 3166-1 country code |
| `zipCode` | string | Postal code / ZIP code |
| `ownerOperatorFirm` | string | Parent company or owner operator firm name |
| `correspondentName` | string | Regulatory correspondent (official contact) name |
| `correspondentPhone` | string | Regulatory correspondent phone number |
| `proprietaryNames` | string | Proprietary product names (brand names) |
| `productCodes` | string | Comma-separated FDA device product codes (e.g., "MQP, LLL, OPN") |
| `deviceNames` | string | Device classification names (e.g., "Infusion pump", "X-ray tube") |
| `medicalSpecialties` | string | Medical specialty descriptions (e.g., "General and Plastic Surgery", "Orthopedic") |
| `registrationExpiryYear` | string | Registration expiry year (YYYY) |

### How to Scrape FDA Device Manufacturer Registrations

#### Step-by-Step Tutorial

1. **Navigate to the Actor** — Open the FDA Medical Device Establishment Registration Scraper on the Apify Store.

2. **Start the Run** — Click **Start** to open the input configuration form.

3. **(Optional) Filter by State** — Enter a 2-letter US state code (e.g., "CA", "TX") to narrow results to a specific state. Leave blank to include all states.

4. **(Optional) Filter by Country** — Enter an ISO country code (e.g., "US", "DE") to filter by manufacturing location. Leave blank for all countries.

5. **(Optional) Search by Firm Name** — Enter a firm name or partial match (e.g., "Boston Scientific", "Abbott") to find specific manufacturers. The search is case-insensitive.

6. **(Optional) Filter by Product Code** — Enter an FDA device product code (e.g., "MQP" for infusion pumps) to isolate establishments manufacturing specific device types. Leave blank to include all product codes.

7. **Set Max Results** — Choose the maximum number of registrations to return (default: 1000, max: 25,000). Set to 0 for unlimited results.

8. **Click Start** — Launch the scraping run.

9. **Download Results** — After the run completes, download results as JSON, CSV, or Excel from the **Dataset** tab.

#### Example Scenarios

- **Supply Chain Mapping** — Search for all manufacturers in "CA" to map your device supply chain in California.
- **Competitive Intelligence** — Search by firm name ("Medtronic") to find all their registered establishments and their product portfolios.
- **Product Sourcing** — Filter by product code ("MQP") to find all manufacturers of infusion pumps in a specific country.
- **Regulatory Compliance** — Extract all establishments in your state to audit supplier compliance and certification status.
- **Market Research** — Download all US-based device manufacturers to analyze market concentration, ownership structure, and product diversity.

### Input Example

```json
{
    "stateCode": "CA",
    "countryCode": "US",
    "firmName": "Boston Scientific",
    "productCode": "",
    "maxResults": 100
}
````

### Output Example

```json
{
    "firmName": "Boston Scientific Corporation",
    "registrationNumber": "1234567",
    "feiNumber": "1234567890",
    "establishmentType": "Manufacturer; Importer",
    "addressLine1": "123 Main Street",
    "addressLine2": "",
    "city": "San Jose",
    "stateCode": "CA",
    "countryCode": "US",
    "zipCode": "95110",
    "ownerOperatorFirm": "Boston Scientific Corporation",
    "correspondentName": "John Smith",
    "correspondentPhone": "408-555-1234",
    "proprietaryNames": "Innervention; CODA; Apex",
    "productCodes": "MQP, LLL, OPN",
    "deviceNames": "Infusion pump; Drainage catheter; Ligation clip",
    "medicalSpecialties": "Cardiovascular; Surgery; Urology",
    "registrationExpiryYear": "2027"
}
```

### Pricing

This Actor fetches data from the free openFDA public API. Computation costs are low as data is retrieved via paginated HTTP requests.

- **Cost per run**: ~$0.001-0.002 (API pagination, no browser required)
- **Actor start event**: Default platform rate
- **Per-result pricing**: $0.003/result

Typical run time for 1,000 results is under 30 seconds.

### Use Cases

- **Supply Chain Intelligence** — Build a database of all device manufacturers by geography, product type, and ownership structure
- **Regulatory Compliance** — Audit supplier registrations, verify FEI numbers, and track registration expiry dates
- **Competitive Market Analysis** — Identify all competitors manufacturing specific device types in your target markets
- **Product Sourcing & Procurement** — Find qualified manufacturers for device component outsourcing and contract manufacturing
- **Regulatory Correspondent Research** — Extract official FDA contact information for regulatory communications
- **Business Development** — Prospect potential acquisition targets or partnership opportunities in specific device categories
- **RAG Pipeline Ingestion** — Clean structured output ready for LLM-based supply chain analysis or regulatory intelligence

### FAQ

**Q: What is the difference between registrations and listings?**
A: The FDA Device Registration & Listing system captures establishment registrations (the facilities) and their product listings (the specific devices manufactured at those facilities). This Actor extracts registrations with their associated product data.

**Q: Can I filter by multiple criteria at once?**
A: Yes. You can combine state, country, firm name, and product code filters in a single run. The Actor applies API-level search (for firm name and product code) and client-side filtering (for state and country).

**Q: What if a firm has multiple establishments?**
A: Each establishment appears as a separate record. You may see multiple registrations from the same firm if they operate multiple facilities.

**Q: Are imports/importers included?**
A: Yes. The `establishmentType` field indicates whether an establishment is a manufacturer, importer, repackager, distributer, or combination thereof.

**Q: How often is the openFDA data updated?**
A: The FDA updates device registration data continuously as new establishments register and existing registrations change. The Actor retrieves the latest data from the live openFDA API.

**Q: What does "ISO country code" mean?**
A: ISO 3166-1 is the international standard for country codes. US = United States, DE = Germany, JP = Japan, etc. Use a 2-letter code.

### Legal Disclaimer

This Actor extracts publicly available data from the U.S. FDA's openFDA database. All data is in the public domain. This Actor is for informational and research purposes only. Users are responsible for compliance with applicable laws and regulations regarding the use of medical device manufacturer data. Always verify data accuracy and current registration status with the FDA directly before making regulatory or business decisions.

### Support

For issues, questions, or feature requests, please contact the Actor author or visit the Apify community forum.

# Actor input Schema

## `stateCode` (type: `string`):

Filter by US state code (e.g., 'CA', 'TX', 'NY'). Leave blank for all states. Case-insensitive.

## `countryCode` (type: `string`):

Filter by ISO country code (e.g., 'US', 'CA', 'DE'). Leave blank for all countries.

## `firmName` (type: `string`):

Filter by establishment/firm name (case-insensitive partial match). Examples: 'Boston Scientific', '3M', 'Abbott'.

## `productCode` (type: `string`):

Filter by FDA device product code (e.g., 'MQP', 'LLL', 'OPN'). Leave blank to include all product codes.

## `maxResults` (type: `integer`):

Maximum number of registration records to return. Set to 0 for unlimited (default: 1000, max: 25000).

## Actor input object example

```json
{
  "stateCode": "",
  "countryCode": "",
  "firmName": "",
  "productCode": "",
  "maxResults": 1000
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/fda-device-registrations-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/fda-device-registrations-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 '{}' |
apify call compute-edge/fda-device-registrations-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=compute-edge/fda-device-registrations-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Medical Device Establishment Registration Scraper",
        "description": "Extract FDA-registered medical device manufacturers and establishments from openFDA. Get firm names, addresses, FEI and registration numbers, establishment types, product codes, device names, and medical specialties. Filter by state, country, firm name, or product code.",
        "version": "0.1",
        "x-build-id": "gnpJKsef170O00kIg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~fda-device-registrations-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-fda-device-registrations-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/compute-edge~fda-device-registrations-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-fda-device-registrations-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/compute-edge~fda-device-registrations-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-fda-device-registrations-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": {
                    "stateCode": {
                        "title": "State Code",
                        "type": "string",
                        "description": "Filter by US state code (e.g., 'CA', 'TX', 'NY'). Leave blank for all states. Case-insensitive.",
                        "default": ""
                    },
                    "countryCode": {
                        "title": "Country Code",
                        "type": "string",
                        "description": "Filter by ISO country code (e.g., 'US', 'CA', 'DE'). Leave blank for all countries.",
                        "default": ""
                    },
                    "firmName": {
                        "title": "Firm Name",
                        "type": "string",
                        "description": "Filter by establishment/firm name (case-insensitive partial match). Examples: 'Boston Scientific', '3M', 'Abbott'.",
                        "default": ""
                    },
                    "productCode": {
                        "title": "Product Code",
                        "type": "string",
                        "description": "Filter by FDA device product code (e.g., 'MQP', 'LLL', 'OPN'). Leave blank to include all product codes.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 25000,
                        "type": "integer",
                        "description": "Maximum number of registration records to return. Set to 0 for unlimited (default: 1000, max: 25000).",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
