# FDA 510(k) Database Search & API: Clearances (`reliable_tools/fda-510k-search`) Actor

Search the FDA 510(k) database by device name, company, product code, K number or decision date. Official openFDA data with device class, regulation, summary PDF link and predicate hints.

- **URL**: https://apify.com/reliable_tools/fda-510k-search.md
- **Developed by:** [Reliable Tools](https://apify.com/reliable_tools) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 clearance records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## FDA 510(k) Database Search & API: Clearances

This FDA 510(k) database search finds premarket notification clearances by device name, company, product code, K
number or decision date, and returns them as clean rows you can filter and export. Each clearance comes with its
official FDA classification (device class, regulation number, classification definition, implant flag), a link to the
510(k) summary PDF and the FDA database page, and a plain-language product category. Describe your own device and every
clearance also gets a predicate hint: is this cleared device a plausible predicate for yours, judged only from official
FDA fields.

### What does FDA 510(k) Search do?

- **Search the 510(k) database** with several filters at once, for example all pulse oximeters cleared since 2025, or
  everything Medtronic got cleared this quarter.
- **Look up K numbers** (and De Novo numbers), many in one run.
- **Join the classification** for each product code, so you see class, regulation and definition next to every
  clearance without a second search.
- **Find predicate candidates.** Give your device's intended use and product code. The Actor lists clearances under
  that code and ranks them as `strong`, `possible` or `unlikely` predicate candidates.

### What data you get

| Field | What it is |
|---|---|
| `kNumber` | 510(k) number (K123456) or De Novo number (DEN123456) |
| `deviceName`, `applicant` | Device name and company as submitted |
| `decisionDate`, `decision`, `decisionCode` | FDA decision, for example Substantially equivalent (SESE) |
| `dateReceived`, `clearanceType` | Submission date; Traditional, Special or Abbreviated |
| `productCode`, `classificationName`, `deviceClass`, `regulationNumber` | Official classification |
| `medicalSpecialty`, `reviewPanel` | Medical specialty and advisory committee |
| `definition`, `implant`, `lifeSustaining` | From the classification record |
| `clearancesWithSameProductCode` | How many 510(k)s exist under the same product code |
| `summaryOrStatement`, `summaryPdfUrl` | Whether a summary was published, and its PDF on accessdata.fda.gov |
| `thirdPartyReview`, `expeditedReview` | Review flags |
| `applicantAddress` | Company address as filed with the 510(k) |
| `productCategory` | Plain-language category such as Patient monitoring or Medical software, with confidence |
| `predicateHint` | For your own device: `strong`, `possible` or `unlikely`, with probability |
| `fdaDatabaseUrl` | The clearance page in the official FDA 510(k) database |

The contact person named in a submission is left out on purpose.

### How to search the FDA 510(k) database step by step

1. Add one or more searches, for example `{"deviceName": "pulse oximeter", "decisionDateFrom": "2025-01-01"}`.
2. Or paste K numbers, one per line.
3. Optional: describe your device under **Your device** to get predicate hints.
4. Click **Start**. The sample input finishes in about 15 seconds.
5. Export to JSON, CSV or Excel, or read the dataset through the API.

All fields in one search must match. To search for two companies, add two searches.

### How do I find predicate devices for my 510(k)?

Put your device into **Your device**:

```json
{"description": "Fingertip pulse oximeter for spot-check SpO2 and pulse rate in adults, for home use", "productCode": "DQA"}
```

The Actor searches all clearances under DQA (newest first) and asks one fixed question per clearance: could this be a
reasonable predicate, meaning the same kind of device with the same intended use and similar technology? The answer
uses only official fields: device name, product code, classification name and definition, class, regulation and
decision date. Code turns the probability into the hint:

| Hint | Probability |
|---|---|
| `strong` | 0.7 or more |
| `possible` | 0.4 to 0.7 |
| `unlikely` | below 0.4 |

In the sample run on 29 October 2026, fingertip oximeters came back `strong` (0.83 to 0.92), an oxygen ring `possible`
(0.64), and reusable SpO2 clip sensors, which are accessories, `unlikely` (0.28). The hint narrows your shortlist. It
is not a regulatory opinion: read the summaries and check the intended use and technological characteristics yourself.

### How much does it cost?

Pay per event:

| Event | Price | When |
|---|---|---|
| Clearance record | $0.002 | Each 510(k) clearance returned, with classification and product category |
| Predicate hint | $0.005 | Each clearance compared with your own device |
| Actor start | $0.00005 | Once per run |

Not charged: K numbers that are not found, invalid numbers, and searches with no match (each gets one free row). Example: 500 clearances cost $1. A predicate search over
the 200 newest clearances of one product code costs $1.40.

### Input

```json
{
  "searches": [
    {"deviceName": "pulse oximeter", "decisionDateFrom": "2025-01-01"},
    {"applicant": "Medtronic", "decisionDateFrom": "2026-07-01"}
  ],
  "kNumbers": ["K163345"],
  "myDevice": {"description": "Fingertip pulse oximeter for spot-check SpO2 and pulse rate in adults, for home use", "productCode": "DQA"},
  "productCategory": true,
  "newestFirst": true,
  "maxResultsPerSearch": 50
}
```

Search fields: `deviceName`, `applicant`, `productCode`, `kNumber`, `decisionDateFrom`, `decisionDateTo`,
`clearanceType`, `advisoryCommittee`, `country`.

### Output

```json
{
  "kNumber": "K163345",
  "deviceName": "TVC Imaging System, TVC Catheter",
  "applicant": "Infraredx, Inc.",
  "decisionDate": "2017-06-21",
  "decision": "Substantially equivalent",
  "dateReceived": "2016-11-29",
  "clearanceType": "Traditional",
  "productCode": "OGZ",
  "classificationName": "Catheter, Intravascular, Plaque Morphology Evaluation",
  "deviceClass": "2",
  "regulationNumber": "870.1200",
  "medicalSpecialty": "Cardiovascular",
  "definition": "Catheter used for delivery of a sensing modality to a coronary or peripheral artery region for determination of atherosclerotic plaque characteristics.  For examination of morphologic features of coronary or peripheral artery lesions or plaques.",
  "implant": false,
  "clearancesWithSameProductCode": 9,
  "summaryPdfUrl": "https://www.accessdata.fda.gov/cdrh_docs/pdf16/K163345.pdf",
  "fdaDatabaseUrl": "https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpmn/pmn.cfm?ID=K163345",
  "productCategory": {"key": "cardiovascular", "label": "Heart and blood vessel devices", "confidence": 0.98},
  "summary": "K163345: TVC Imaging System, TVC Catheter by Infraredx, Inc., Substantially equivalent on 2017-06-21, product code OGZ (class 2)."
}
```

### Use cases

- **Regulatory affairs:** shortlist predicate devices and pull their summaries for a new 510(k).
- **Competitive intelligence:** track every clearance of a competitor or a product code.
- **Medtech sales and BD:** find companies that just cleared a device in your field.
- **Investors and analysts:** count clearances per company, product code or panel over time.
- **Distributors and hospitals:** confirm that a device on offer has a 510(k) and see its class.

### Why not the openFDA API or the FDA website directly?

The FDA website searches one form at a time. The openFDA API is free and this Actor uses it, but the raw API needs
query syntax, returns at most 1,000 rows per call, and keeps the classification in a separate endpoint. This Actor runs
many searches in one go, pages for you, joins the classification for each product code, adds the summary PDF link,
and adds the product category and predicate hints.

### FAQ

#### Is this official FDA data?

Yes. Rows come from the openFDA device 510(k) and device classification endpoints, which FDA publishes as public data
with a CC0 dedication. FDA notes that openFDA data is not validated for clinical decisions; check the official FDA
database page linked in each row before you rely on it.

Data provided by the U.S. Food and Drug Administration (open.fda.gov). Not affiliated with or endorsed by FDA.

#### Can I use 510(k) data commercially?

FDA publishes openFDA data as public domain with a CC0 1.0 dedication, which allows commercial reuse. Most applicants
are companies, but some submitters are individuals or consultants, so an applicant name and address can be personal
data; handle it under the privacy rules that apply to you. The contact person listed in submissions is left out. You
are responsible for your own use; this README is not legal advice.

#### Does the FDA 510(k) database have an API?

Yes, openFDA. This Actor is a layer on it with classification join, PDF links and predicate hints. See "Why not
the openFDA API or the FDA website directly?" above.

#### How much does it cost?

$0.002 per clearance and $0.005 per predicate hint. 1,000 clearances cost $2.

#### Does it read the 510(k) summary PDFs?

No. Predicate hints use only the structured official fields. The summary PDF link is in each row so you can read the
predicate device and the comparison table yourself.

#### How current is the data?

openFDA updates the 510(k) data regularly, and each run reads the live openFDA data. The date of openFDA's last update
is part of every openFDA response.

#### Can I use it from Python, n8n, Make or an AI agent (MCP)?

Yes. Every Apify Actor has a REST API, Python and JavaScript clients, and integrations with n8n, Make, Zapier and
MCP-capable AI agents. See the API tab.

#### Can I get alerts for new clearances?

Yes. Save a search with `decisionDateFrom` as an Actor task and schedule it weekly.

#### Do I need an openFDA key?

openFDA asks API users to get a free API key. Without a key, openFDA allows 240 requests per minute and 1,000 requests
per day per IP address, and the Actor runs on shared cloud addresses. For regular or larger use, add your own free
openFDA key in the input (with a key the daily limit is 120,000). Either way the Actor stays below 240 requests per
minute and stops after a fixed number of requests per run (900 without a key, 5,000 with a key).

### About Reliable Tools

[Reliable Tools](https://apify.com/reliable_tools) builds compliance and lookup Actors on official public registries,
with calibrated AI checks where a plain lookup leaves a question open. Found a problem or need a field? Open an issue on
the Issues tab and we answer fast.

# Actor input Schema

## `searches` (type: `array`):

One object per search; all fields in one object must match. Fields: "deviceName" (words in the device name), "applicant" (company), "productCode" (three letters such as DQY), "kNumber", "decisionDateFrom" and "decisionDateTo" (YYYY-MM-DD), "clearanceType" (Traditional, Special, Abbreviated), "advisoryCommittee" (for example Cardiovascular), "country" (two letters).

## `kNumbers` (type: `array`):

Look up 510(k) or De Novo numbers directly, one per line (K163345, DEN200001).

## `myDevice` (type: `object`):

Optional. Describe your own device with "description" (intended use and technology in plain words) and, if you know it, "productCode". Every clearance found then gets a predicate hint (strong, possible, unlikely) with a probability, based only on official FDA fields. With a product code, all clearances under that code are searched too.

## `searchMyProductCode` (type: `boolean`):

When your device has a product code, add a search for all clearances with that code.

## `productCategory` (type: `boolean`):

Adds a plain-language category (for example Patient monitoring, Orthopedic devices, Medical software) from the official classification.

## `newestFirst` (type: `boolean`):

Sort each search by decision date, newest first.

## `maxResultsPerSearch` (type: `integer`):

openFDA returns up to 26,000 results per search.

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

Stops after this many clearances.

## `openFdaApiKey` (type: `string`):

Your own free openFDA key, recommended for regular use (openFDA asks API users to get one). Without a key openFDA allows 240 requests per minute and 1,000 per day per IP address; with a key, 240 per minute and 120,000 per day. The Actor stays below 240 per minute and makes at most 900 requests per run without a key, 5,000 with a key.

## Actor input object example

```json
{
  "searches": [
    {
      "deviceName": "pulse oximeter",
      "decisionDateFrom": "2025-01-01"
    },
    {
      "applicant": "Medtronic",
      "decisionDateFrom": "2026-07-01"
    }
  ],
  "kNumbers": [
    "K163345"
  ],
  "myDevice": {
    "description": "Fingertip pulse oximeter for spot-check SpO2 and pulse rate in adults, for home use",
    "productCode": "DQA"
  },
  "searchMyProductCode": true,
  "productCategory": true,
  "newestFirst": true,
  "maxResultsPerSearch": 50,
  "maxResults": 5000
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset in the clearances view.

## `summary` (type: `string`):

Counts, requests and the data source.

# 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 = {
    "searches": [
        {
            "deviceName": "pulse oximeter",
            "decisionDateFrom": "2025-01-01"
        },
        {
            "applicant": "Medtronic",
            "decisionDateFrom": "2026-07-01"
        }
    ],
    "kNumbers": [
        "K163345"
    ],
    "myDevice": {
        "description": "Fingertip pulse oximeter for spot-check SpO2 and pulse rate in adults, for home use",
        "productCode": "DQA"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reliable_tools/fda-510k-search").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 = {
    "searches": [
        {
            "deviceName": "pulse oximeter",
            "decisionDateFrom": "2025-01-01",
        },
        {
            "applicant": "Medtronic",
            "decisionDateFrom": "2026-07-01",
        },
    ],
    "kNumbers": ["K163345"],
    "myDevice": {
        "description": "Fingertip pulse oximeter for spot-check SpO2 and pulse rate in adults, for home use",
        "productCode": "DQA",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reliable_tools/fda-510k-search").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 '{
  "searches": [
    {
      "deviceName": "pulse oximeter",
      "decisionDateFrom": "2025-01-01"
    },
    {
      "applicant": "Medtronic",
      "decisionDateFrom": "2026-07-01"
    }
  ],
  "kNumbers": [
    "K163345"
  ],
  "myDevice": {
    "description": "Fingertip pulse oximeter for spot-check SpO2 and pulse rate in adults, for home use",
    "productCode": "DQA"
  }
}' |
apify call reliable_tools/fda-510k-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reliable_tools/fda-510k-search"
        }
    }
}
```

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/xddaBGRriCYAk8cn6/builds/GbxqM7CwdgzfGk4oD/openapi.json