# FDA Device Clearances Watch — New 510(k) & PMA Approvals (`oneshotventure/fda-clearances`) Actor

Get newly cleared FDA 510(k) devices and approved PMA records since your last successful run. Filter by keywords, applicant, or product code for regulatory, competitive-intelligence, and sales workflows.

- **URL**: https://apify.com/oneshotventure/fda-clearances.md
- **Developed by:** [Nick](https://apify.com/oneshotventure) (community)
- **Categories:** Automation, Agents, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 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/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

## FDA 510(k) & PMA Clearances Monitor — New Device Approvals

Track **newly cleared FDA medical devices since your last run** — 510(k) clearances and PMA approvals
— from the official openFDA device APIs. Filter by keyword, applicant or product code. Clean JSON
built for regulatory, competitive-intelligence and medtech sales workflows.

### What does this Actor do?

It reads openFDA's two device decision endpoints — `device/510k` for premarket notifications and
`device/pma` for premarket approvals — over a date window, merges them into one schema, and emits the
result as a scheduled change feed.

The merge is the work, because **510(k) and PMA are not the same kind of record.** A 510(k) has a
K-number, a `device_name` and a prose decision description. A PMA has a P-number, a `trade_name` *and*
a `generic_name`, a decision *code* rather than a description, and can carry a supplement number for
a subsequent change to an approved device. Rather than force one onto the other, this Actor maps both
onto a shared shape, marks which side each row came from in `source`, and leaves genuinely
source-specific fields `null`. PMA supplements get a compound `clearanceId` like `P980022/S045`, so a
supplement never collides with its parent approval.

Every row carries a direct link into the FDA's own CDRH database, and the untouched source record
stays in `raw`.

### Who is it for?

- **Medtech competitive intelligence teams** watching what rivals just got cleared to sell.
- **Regulatory affairs professionals** tracking decisions in their product codes and advisory panels.
- **Medical device sales teams** who want to reach a manufacturer at the moment a device clears.
- **Investors and analysts** monitoring a company's regulatory milestones as they become public.
- **AI agent builders** who want an FDA device tool with a stable output schema.

### Use cases

- Watch a product code and get every new clearance in that device category.
- Monitor named competitors by `applicants` and see their approvals the week they land.
- Track a device keyword — `infusion pump`, `continuous glucose`, `surgical robot` — across both
  pathways at once.
- Feed new clearances into a competitive-intelligence digest with the FDA link attached.
- Give an agent a tool that answers "what devices were cleared in this category recently?"

### What you get

One row per clearance or approval. Any value a source does not publish is `null` — the field is
always present, and the untouched source record stays in `raw`.

| Field | Type | Description |
|---|---|---|
| `source` | string | `510k` or `pma` |
| `clearanceId` | string | K-number for 510(k). For PMA, the P-number, with `/supplement` appended where the record is a supplement |
| `deviceName` | string | 510(k) device name, or the PMA trade name |
| `genericName` | string | Generic device name. **PMA only** — always `null` on 510(k) rows |
| `applicant` | string | Company that filed for the clearance or approval |
| `decisionDate` | string | FDA decision date, as an ISO 8601 UTC midnight timestamp |
| `decisionDescription` | string | 510(k): the decision description in prose. PMA: the decision *code* |
| `clearanceType` | string | 510(k) clearance type, e.g. `Traditional`, `Special`. Literally `PMA` on PMA rows |
| `productCode` | string | FDA product code for the device category |
| `advisoryCommittee` | string | Advisory committee / medical specialty panel description |
| `expedited` | boolean | `true` where the FDA flagged expedited review, otherwise `null` |
| `url` | string | Direct link to the record in the FDA CDRH database |
| `raw` | object | The complete original openFDA record, unmodified |
| `newSinceLastRun` | boolean | Whether the decision date is newer than the saved watermark |
| `retrievedAt` | string | ISO 8601 timestamp of when this row was fetched |

#### Sample output record

```json
{
  "source": "510k",
  "clearanceId": "K261847",
  "deviceName": "Example Ambulatory Infusion Pump",
  "genericName": null,
  "applicant": "Example Medical Systems, Inc.",
  "decisionDate": "2026-08-07T00:00:00.000Z",
  "decisionDescription": "Substantially Equivalent",
  "clearanceType": "Traditional",
  "productCode": "LKK",
  "advisoryCommittee": "General Hospital",
  "expedited": null,
  "url": "https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpmn/pmn.cfm?ID=K261847",
  "raw": { "k_number": "K261847", "…": "…" },
  "newSinceLastRun": true,
  "retrievedAt": "2026-08-23T10:31:44.208Z"
}
```

### How to use it

#### Watch a device category

```json
{
  "sources": ["510k", "pma"],
  "keywords": ["infusion pump"],
  "productCodes": ["LKK"],
  "maxResults": 25
}
```

#### Track named competitors

`applicants` matches the applicant field as a case-insensitive substring, so a partial company name
works.

```json
{
  "sources": ["510k", "pma"],
  "applicants": ["Medtronic", "Boston Scientific"],
  "maxResults": 100
}
```

#### PMA approvals only, from an explicit date

```json
{
  "sources": ["pma"],
  "decidedSince": "2026-07-01",
  "maxResults": 200
}
```

### Input parameters

| Input | Type | Description |
|---|---|---|
| `sources` | array | Which pathways to monitor: `510k`, `pma`. Default: both |
| `keywords` | array | Optional, case-insensitive. Matches against device name, generic name and applicant together |
| `applicants` | array | Optional, case-insensitive substring match on the applicant |
| `productCodes` | array | Optional. **Exact** match on the FDA product code |
| `decidedSince` | string | Optional `YYYY-MM-DD` start date that overrides the saved watermark |
| `maxResults` | integer | Maximum total records across all sources (1–1000). Default: `100` |

Passing a source other than `510k` or `pma` fails the run with a clear error rather than silently
returning nothing.

### How monitoring works (first run and scheduling)

The first run retrieves the **prior 30 days** and saves a watermark only after records have been
emitted successfully. To get only-new records on every subsequent run, **schedule this Actor as a
saved Task** so runs share the same storage — the watermark lives in the task's key-value store. A
fresh unsaved run starts a fresh baseline.

A failed source emits no partial results and does not advance the watermark, so a transient outage
cannot silently skip a window. An empty result from openFDA is treated as "nothing in this window",
not as a failure.

### Honest limitations

- **Filtering happens after retrieval.** `keywords`, `applicants` and `productCodes` are applied to
  the records this Actor fetched, not pushed down into the openFDA query. A narrow filter over a busy
  window can therefore return far fewer rows than `maxResults`, because the cap is applied to what was
  fetched first. Widen `decidedSince` if a specific filter looks under-productive.
- **`maxResults` is a total across sources**, consumed in the order you list them. Cap at 100 with
  `510k` first and a busy month, and `pma` may contribute nothing that run.
- **`genericName` is PMA-only** and is always `null` on 510(k) rows, because the 510(k) endpoint does
  not publish it.
- **`decisionDescription` means different things per source.** On 510(k) it is prose
  ("Substantially Equivalent"); on PMA it is the raw decision *code*. Read it together with `source`.
- **`expedited` is `true` or `null`, never `false`.** The FDA sets a flag when review was expedited
  and publishes nothing when it was not, so absence is not a documented negative.
- **`productCodes` is exact matching**, not a prefix or a substring. `LKK` will not match `LKKA`.
- **Clearance is not the same as marketing.** A 510(k) clearance or PMA approval means the FDA
  permitted the device; it does not tell you the device shipped, or when.
- **Decision dates can be revised upstream.** openFDA republishes its device files periodically, so a
  record can appear slightly after its decision date.

### Reliability

Per-source diagnostics are written to the `RUN_SUMMARY` key-value record — never into your paid
results. Failures carry structured reason codes and prevent the watermark from advancing. The Actor
identifies itself to openFDA and rate-limits its requests.

Every record carries `retrievedAt`, a `url` into the FDA's own CDRH database, and the untouched source
record in `raw`, so you can check any row against the agency yourself.

Maintained against the upstream API. If openFDA changes its schema or an endpoint moves, report it
through the Issues tab and it gets fixed.

### Integrations

Connect this Actor to Make, Zapier, n8n, Slack, Google Sheets, Airtable or any HTTP endpoint through
Apify integrations. A weekly Task can post new clearances in your product codes into a regulatory
channel, or fire a webhook so a competitive-intelligence digest is assembled the moment a decision
publishes. Datasets export as JSON, CSV, Excel, XML, RSS or HTML.

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/oneshotventure~fda-clearances/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sources": ["510k"], "keywords": ["infusion pump"], "maxResults": 25}'
```

Python, JavaScript, PHP and CLI clients are documented under
[Apify API clients](https://docs.apify.com/api/client).

### Use with AI agents (MCP)

This Actor is callable from any MCP-compatible client — Claude, Cursor, VS Code or your own agent —
through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). The input schema is
fully described and every record uses one stable, flat JSON shape, so an agent can call it and read
the result without a parsing step. Because it reads the official openFDA API rather than a rendered
page, the answer an agent gets is the same one the source publishes.

*Factual regulatory data. Not medical, clinical or investment advice.*

### Frequently asked questions

#### Is there a free FDA 510(k) API?

Yes — openFDA publishes both the 510(k) and PMA device decision datasets as an open API with no key
required. This Actor is the merging, filtering and change-feed layer over both.

#### What is the difference between a 510(k) and a PMA?

A 510(k) is a premarket notification: the manufacturer shows the device is substantially equivalent to
one already on the market. A PMA is premarket approval, the stricter pathway for higher-risk devices,
requiring clinical evidence of safety and effectiveness. This Actor covers both, tagged in `source`.

#### How do I track new device clearances for a competitor?

Put their company name in `applicants` — matching is a case-insensitive substring, so a partial name
works — save the Actor as a Task, and schedule it.

#### How do I monitor a specific device category?

Use `productCodes` with the FDA product code, which is exact-matched. Add `keywords` if you would
rather match on device naming than on the code.

#### What is a product code?

A three-letter FDA classification identifying a device type, e.g. `LKK`. It is the most precise way to
scope this feed, and every output row carries the one it matched.

#### Does this include device recalls or adverse events?

No. This Actor covers clearance and approval decisions only. For recalls and enforcement, see the
recalls Actor below.

#### Does clearance mean the device is on sale?

No. It means the FDA permitted marketing. Whether and when the manufacturer actually ships is not in
this data.

#### Why did my filtered run return so few results?

Because filters are applied after retrieval. Widen the window with `decidedSince` or raise
`maxResults` so more records are fetched before your filter narrows them.

### Related actors

- [US Product Recalls Monitor](https://apify.com/oneshotventure/recalls-monitor) — CPSC and FDA food,
  drug and device recalls and enforcement reports.
- [ClinicalTrials.gov Monitor](https://apify.com/oneshotventure/trials-watch) — newly posted studies
  by condition and sponsor.
- [NPI Registry Lookup](https://apify.com/oneshotventure/npi-lookup) — US healthcare provider search
  and verification.
- [Federal Register Monitor](https://apify.com/oneshotventure/fedreg-watch) — new FDA rules, proposed
  rules and notices.

### Disclaimer

Unofficial independent tool. Not affiliated with or endorsed by the FDA or openFDA. Data is public
government data retrieved from the official openFDA API.

# Actor input Schema

## `sources` (type: `array`):

Sources to monitor. Allowed values: 510k, pma.

## `keywords` (type: `array`):

Optional case-insensitive keywords matched against device name, generic name, and applicant.

## `applicants` (type: `array`):

Optional case-insensitive applicant substrings.

## `productCodes` (type: `array`):

Optional exact FDA product codes.

## `decidedSince` (type: `string`):

Optional YYYY-MM-DD date that overrides the saved watermark as the window start.

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

Maximum total records across all sources (1-1000).

## Actor input object example

```json
{
  "sources": [
    "510k"
  ],
  "keywords": [],
  "applicants": [],
  "productCodes": [],
  "maxResults": 25
}
```

# Actor output Schema

## `records` (type: `string`):

Normalized clearance records in the default dataset.

## `runSummary` (type: `string`):

Run diagnostics stored as RUN\_SUMMARY in the key-value store.

# 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 = {
    "sources": [
        "510k"
    ],
    "keywords": [],
    "applicants": [],
    "productCodes": [],
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("oneshotventure/fda-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 = {
    "sources": ["510k"],
    "keywords": [],
    "applicants": [],
    "productCodes": [],
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("oneshotventure/fda-clearances").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 '{
  "sources": [
    "510k"
  ],
  "keywords": [],
  "applicants": [],
  "productCodes": [],
  "maxResults": 25
}' |
apify call oneshotventure/fda-clearances --silent --output-dataset

```

## MCP server setup

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

```

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/lHXupq3YONB1mlLZj/builds/65eAUrhp0UcOIKv5V/openapi.json