# FDA 510(k) Clearances Scraper — 11 Fields, No API Key (`themineworks/fda-510k-device-clearances`) Actor

Scrape FDA 510(k) medical device clearances by company, device, or product code. Returns applicant, decision date, decision type & panel for medtech competitive intel and regulatory affairs. No API key. Use it as an MCP server in Claude, ChatGPT & AI agents.

- **URL**: https://apify.com/themineworks/fda-510k-device-clearances.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Other, Business, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 clearance scrapeds

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 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

## 🩻 FDA 510(k) Scraper: Device Clearances & Medtech Intel

### Overview

FDA 510(k) Scraper pulls medical device clearance records straight from openFDA's 510(k) endpoint. Search by applicant company (Medtronic, Boston Scientific), device name, FDA product code, or decision type, and filter by decision date. Get back applicant, device name, product code, decision code, decision date, panel, and 510(k) number for every matching clearance. No API key required.

It's the fastest way to run medtech competitive intelligence, monitor regulatory approvals in a category, or feed a compliance dashboard with authoritative FDA clearance data.

Reliability posture: each clearance is only charged once it has actually been written to the dataset, so a blocked, empty, or failed run is never charged.

✅ No API key required | ✅ Applicant + device search | ✅ Product-code filter | ✅ MCP-ready for AI agents

### Features

Applicant search. Track every clearance a specific company has received.
Product-code filter. FDA 3-letter classification codes (e.g. `FRN` for infusion pumps).
Decision type. SE (Substantially Equivalent) or NSE (Not Substantially Equivalent).
Date range. Filter clearances from a specific date.
Bulk pull. Up to 2,000 clearances per run.

### How it works

The actor talks to the openFDA `/device/510k` endpoint, which mirrors the official FDA 510(k) clearance database. Your inputs are converted into openFDA's Lucene-style query and posted with pagination handled automatically until the `maxResults` budget is reached.

Every clearance is normalised to a flat JSON row: applicant, device name, product code, decision code, decision date, panel, and 510(k) number. The 510(k) number links back to the FDA's own detail page for each clearance.

### 🧾 Input configuration

```json
{
  "applicant": "Medtronic",
  "deviceName": "infusion pump",
  "productCode": "FRN",
  "decisionType": "SE",
  "dateFrom": "2024-01-01",
  "maxResults": 200
}
```

### 📤 Output format

Captured from a live run against `applicant: "Medtronic"`:

```json
{
  "k_number": "K261866",
  "applicant": "Medtronic, Inc.",
  "device_name": "Concerto Versa™ Detachable Coil",
  "product_code": "KRD",
  "decision_code": "SESE",
  "decision_description": "Substantially Equivalent",
  "decision_date": "2026-06-24",
  "advisory_committee": "Cardiovascular",
  "url": "https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpmn/pmn.cfm?ID=K261866",
  "scraped_at": "2026-07-15T04:15:32.480Z"
}
```

Note: openFDA's own `device_name` field occasionally contains a mis-encoded trademark symbol from the source registry; this record has been cleaned of that artifact for readability, everything else is exactly as delivered. Every clearance record contains these fields:

| Field | Description |
| --- | --- |
| 🆔 `k_number` | FDA 510(k) number (e.g. `K230001`) |
| 🏢 `applicant` | Applicant company name |
| 🩻 `device_name` | Name of the medical device |
| 🔖 `product_code` | FDA product classification code |
| ✅ `decision_code` | Decision code (e.g. `SESE` for Substantially Equivalent) |
| 📝 `decision_description` | Human-readable decision description |
| 📅 `decision_date` | Date the decision was issued |
| 🧑‍⚕️ `review_panel` | FDA review panel (null on many records; openFDA does not always populate it) |
| 🧑‍⚕️ `advisory_committee` | Advisory committee description that reviewed the submission |
| 🔗 `url` | Link to the clearance's official FDA detail page |
| 🕒 `scraped_at` | ISO timestamp of when the record was captured |

### 💼 Common use cases

**Medtech competitive intelligence**
Pull every clearance a competitor has received in the last 24 months and cluster by product code.
Track how fast a category is growing by clearance volume per year.

**Regulatory affairs**
Monitor product codes relevant to your portfolio and alert on new clearances.
Build a benchmark of clearance timelines (date received to date decided) for planning submissions.

**Investment research**
Screen medtech startups by their clearance history and pace.
Confirm claimed clearances against the FDA source of truth.

**AI agents & RAG**
Give a regulatory or research agent a fast tool for "what clearances exist for X?" from any conversation.

### 🚀 Getting started

1. Open the actor and enter an `applicant` (company), `deviceName`, or `productCode`.
2. Optionally set `decisionType` (`SE` cleared, `NSE` not cleared) and `dateFrom`.
3. Set `maxResults` to control cost.
4. Click Start. Records stream to the dataset as pages parse.
5. Download as JSON, CSV, or Excel, or pull via API or MCP.

### FAQ

**Where does the data come from?**
Directly from the openFDA `/device/510k` endpoint, which mirrors the official FDA 510(k) clearance database on fda.gov.

**How current is the data?**
openFDA refreshes clearance data on FDA's cadence, typically several times per week. Each run fetches live at request time.

**How much does it cost?**
Pay per clearance returned, pay as you go. No subscription, no monthly minimum.

**Can I use it in an AI agent?**
Yes. It's exposed as an MCP tool. See below.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/fda-510k-device-clearances
```

Or call it programmatically with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/fda-510k-device-clearances').call({
  applicant: 'Medtronic',
  dateFrom: '2024-01-01',
  maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### 🛠️ Complete your medtech intel pipeline

Got the clearances. Now build the wider picture:

- **[FDA Recalls Scraper](https://apify.com/themineworks/fda-recalls-scraper)**: pull enforcement history for the same firm or category.
- **[PubMed NCBI Scraper](https://apify.com/themineworks/pubmed-ncbi-scraper)**: pull published clinical evidence on the device.
- **[NPI Registry Scraper](https://apify.com/themineworks/npi-registry-healthcare)**: find the healthcare providers using devices in the category.

Typical flow: fda-510k surfaces the clearances, fda-recalls checks enforcement, pubmed adds clinical evidence.

Questions or need a custom field set? Reach out through the Apify profile.

# Actor input Schema

## `applicant` (type: `string`):

Company that submitted the 510(k) (e.g. Medtronic, Boston Scientific).

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

Device or product name (partial match).

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

FDA 3-letter product classification code (e.g. FRN for infusion pumps).

## `decisionType` (type: `string`):

SE = Substantially Equivalent (cleared), NSE = Not Substantially Equivalent. Leave blank for all.

## `dateFrom` (type: `string`):

Filter decisions from this date.

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

Maximum clearances to return.

## Actor input object example

```json
{
  "applicant": "Medtronic",
  "dateFrom": "2020-01-01",
  "maxResults": 25
}
```

# Actor output Schema

## `results` (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 = {
    "applicant": "Medtronic",
    "dateFrom": "2020-01-01",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/fda-510k-device-clearances").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 = {
    "applicant": "Medtronic",
    "dateFrom": "2020-01-01",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/fda-510k-device-clearances").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 '{
  "applicant": "Medtronic",
  "dateFrom": "2020-01-01",
  "maxResults": 25
}' |
apify call themineworks/fda-510k-device-clearances --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Rk6ZYBLl59GULHqs8/builds/8op9KaThEcIXf3CT2/openapi.json