# FDA 510(k) Clearances Feed: New Device Clearances + PMA (`moment-data/fda-510k-clearances-feed`) Actor

New FDA medical device 510(k) clearances and optional PMA approvals from the official openFDA API. Filter by product code, specialty, company, decision or keyword. Review days computed, FDA links included, 'new since last run' mode for schedules.

- **URL**: https://apify.com/moment-data/fda-510k-clearances-feed.md
- **Developed by:** [Luke Miller](https://apify.com/moment-data) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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.

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) Clearances Feed: new medical device clearances and PMA approvals

Get a clean, analysis-ready feed of **new FDA medical device 510(k) clearances**, plus optional **PMA approvals and supplements**, straight from the official **openFDA** API. Filter by **FDA product code**, **advisory committee / medical specialty**, **applicant company**, **decision code**, **clearance type** or **device name keyword**. Each record has computed **FDA review days** and a direct link to the FDA 510(k) or PMA database page. Turn on **"new since last run"** mode and schedule it for a daily or weekly alert feed of new FDA device clearances.

No API key, no login, no scraping. The data is official US government public data (openFDA, CC0).

### Who it's for

- **Medtech competitive intelligence:** see the moment a competitor gets a device cleared in your product code. Track predicate trends, new entrants and review times.
- **Investors and analysts:** follow regulatory milestones for public and private medtech companies. Track 510(k) and PMA activity by company or specialty, and spot De Novo grants.
- **Regulatory affairs consultants:** benchmark FDA review times (`reviewDays`) by product code, panel and pathway (Traditional, Special, Abbreviated), and find recent predicates.
- **Medtech sales and business development teams:** newly cleared devices often mean launches, hiring, and a need for distributors, contract manufacturers, CROs, marketing and launch agencies. Use the feed as a list of companies with a fresh reason to talk.
- **Journalists and newsletter writers:** get a weekly digest of new AI, robotic, cardiovascular and digital-health device clearances.

### What you get (one record per FDA decision)

| Field | Example |
|---|---|
| `recordType` | `510(k)`, `PMA original`, `PMA supplement` |
| `kNumber` / `pmaNumber` + `supplementNumber` | `K262000` / `P200026` + `S019` |
| `deviceName` | `Sway System (Sports Plus)` |
| `applicant`, `applicantCountry` | `Sway Medical, Inc.`, `US` |
| `productCode`, `productCodeName`, `deviceClass`, `regulationNumber` | `POM`, `Computerized Cognitive Assessment Aid For Concussion`, `2`, `882.1471` |
| `advisoryCommittee`, `advisoryCommitteeCode` | `Neurology`, `NE` |
| `decisionDate`, `decisionCode`, `decisionDescription` | `2026-10-18`, `SESE`, `Substantially Equivalent` |
| `dateReceived`, `reviewDays` (computed) | `2026-06-15`, `125` |
| `clearanceType` | `Traditional`, `Special`, `Abbreviated`, `PMA` |
| `thirdPartyReview`, `expeditedReview`, `statementOrSummary` | `false`, `null`, `Summary` |
| `fdaUrl` | Link to the record on the FDA 510(k)/PMA database |
| PMA only: `genericName`, `supplementType`, `supplementReason`, `approvalOrderStatement` | |

Entity-level data only: contact person names and street addresses in the FDA source are **dropped** on purpose.

### Quick start

1. Click **Start** with the default input `{}`. You get the 30 newest 510(k) clearances from the last 60 days in a few seconds.
2. Narrow it down with filters, for example:

```json
{
  "advisoryCommittees": ["Cardiovascular", "RA"],
  "deviceNameKeywords": ["catheter", "AI"],
  "includePMA": true,
  "maxItems": 200
}
```

```json
{ "applicants": ["Medtronic", "Stryker", "Boston Scientific"], "includePMA": true, "includePmaSupplements": false }
```

```json
{ "productCodes": ["QAS", "LLZ"], "decisionCodes": ["SESE"] }
```

3. **Alert feed (recommended for schedules):** set `"mode": "sinceLastRun"` and a `stateKey` such as `"cardio-watch"`. Each run then returns only clearances it has not delivered before for that key. Create a **Schedule** in Apify Console (daily or weekly, e.g. Monday 7 am) and connect a webhook, Slack, email, Google Sheets, Zapier or Make integration to receive the new rows automatically.

```json
{ "mode": "sinceLastRun", "stateKey": "cardio-watch", "advisoryCommittees": ["CV"], "lookbackDays": 60, "maxItems": 500 }
```

**Schedule tip:** openFDA refreshes device data about weekly, and FDA decisions appear in it with a lag (the newest records are typically 1-3 weeks old). A daily or weekly schedule in `sinceLastRun` mode with `lookbackDays` of 60 catches late-published decisions without duplicates. Check `dataLastUpdated` in the run summary (`OUTPUT` record).

### Input

| Input | Default | Notes |
|---|---|---|
| `mode` | `window` | `window` = newest matches in the lookback window. `sinceLastRun` = only records not delivered before (per `stateKey`). |
| `lookbackDays` | `60` | Window by FDA decision date (7-3650). |
| `productCodes` | all | 3-letter FDA product codes. |
| `advisoryCommittees` | all | Codes (`CV`, `OR`, `RA`, `NE`, `GU`, `DE`, `HO`, `SU`, `CH`, `IM`...) or names (`Cardiovascular`). |
| `applicants` | all | Company name words. Any match counts. |
| `decisionCodes` | all | `SESE`, `SESK`, `SESD`, `DENG` (De Novo), PMA `APPR`, `OK30`... |
| `deviceNameKeywords` | all | Words in the device/trade name. |
| `clearanceTypes` | all | `Traditional`, `Special`, `Abbreviated`, `Direct`. |
| `includePMA` | `false` | Add PMA decisions (class III). |
| `includePmaSupplements` | `true` | Untick to get original PMA approvals only. |
| `maxItems` | `30` | Hard cap on records (and spend). |
| `stateKey` | `default` | One per schedule. |
| `openfdaApiKey` | none | Optional free openFDA key for very high volumes. |

Different filters are combined with AND. Values within one filter are combined with OR.

### Sample output

```json
{
  "recordType": "510(k)",
  "kNumber": "K262000",
  "deviceName": "Sway System (Sports Plus)",
  "applicant": "Sway Medical, Inc.",
  "applicantCountry": "US",
  "productCode": "POM",
  "productCodeName": "Computerized Cognitive Assessment Aid For Concussion",
  "deviceClass": "2",
  "advisoryCommittee": "Neurology",
  "decisionDate": "2026-10-18",
  "decisionCode": "SESE",
  "decisionDescription": "Substantially Equivalent",
  "dateReceived": "2026-06-15",
  "reviewDays": 125,
  "clearanceType": "Traditional",
  "fdaUrl": "https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpmn/pmn.cfm?ID=K262000"
}
```

See `sample-output.json` for full records.

### Pricing

Pay per event (Apify takes care of billing; you only pay for what is delivered):

| Event | Price | Charged |
|---|---|---|
| `apify-actor-start` | $0.005 | once per run |
| `clearance-record` | $0.004 | per 510(k) clearance or PMA approval delivered |

A default test run (30 records) costs about $0.125. A weekly product-code watch (~10 new clearances/week) costs about $0.045/week. `maxItems` and Apify's *max cost per run* cap your spend; the Actor stops delivering when your budget is reached, so you are never charged for more than you set. No separate platform-usage charges: compute is included in the event prices.

### FAQ

**Why are the newest records a week or more old?** openFDA updates device data about weekly, and the FDA publishes decisions after a delay. The Actor reads the official source, so freshness matches openFDA. `sinceLastRun` mode handles late-published decisions automatically.

**Is this data allowed to be reused?** Yes. openFDA data is public domain (CC0). This Actor is not affiliated with or endorsed by the FDA. Don't use it for clinical decisions.

**Can I get De Novo grants?** Yes. De Novo decisions appear in the 510(k) data with decision code `DENG`.

**Rate limits?** The Actor makes paced, keyless requests (well under openFDA's limits) and retries politely on throttling.

# Actor input Schema

## `mode` (type: `string`):

window (default): newest matching FDA decisions in the last N days, no saved state. sinceLastRun: only clearances not delivered before for this State key; use this for daily or weekly schedules.

## `lookbackDays` (type: `integer`):

openFDA publishes device decisions about weekly, so the newest records are usually 1-3 weeks old. Keep this at 30+ days.

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

Three-letter FDA product codes, e.g. QAS, DQY, LLZ, POM. Empty = all.

## `advisoryCommittees` (type: `array`):

Two-letter codes (CV, OR, RA, NE, GU, DE, HO, SU, CH, IM...) or names (Cardiovascular, Orthopedic, Radiology, Neurology, Dental...). Empty = all.

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

Company names or name words, e.g. Medtronic, Siemens Healthineers, Stryker. Any match counts.

## `decisionCodes` (type: `array`):

e.g. SESE (substantially equivalent), SESK, SESD, DENG (De Novo granted); PMA: APPR, OK30. Empty = all.

## `deviceNameKeywords` (type: `array`):

Words or phrases in the device (trade) name, e.g. catheter, AI, robotic, CGM. Any match counts.

## `clearanceTypes` (type: `array`):

Traditional, Special, Abbreviated, Direct. Empty = all.

## `includePMA` (type: `boolean`):

Also return Premarket Approval decisions (class III devices) from openFDA device/pma.

## `includePmaSupplements` (type: `boolean`):

When PMA is on: include supplements (labeling, manufacturing, 30-day notices). Untick for original PMA approvals only.

## `maxItems` (type: `integer`):

Hard cap on delivered records (also caps your spend). Small default so a first test is quick and cheap.

## `stateKey` (type: `string`):

Name of the saved search for sinceLastRun mode. Use one key per schedule.

## `openfdaApiKey` (type: `string`):

Free key from open.fda.gov raises the daily request limit. Not needed for normal use.

## Actor input object example

```json
{
  "mode": "window",
  "lookbackDays": 60,
  "includePMA": false,
  "includePmaSupplements": true,
  "maxItems": 30,
  "stateKey": "default"
}
```

# Actor output Schema

## `clearances` (type: `string`):

One record per 510(k) clearance or PMA decision.

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

Window, filters, match counts, openFDA last-updated date.

# 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("moment-data/fda-510k-clearances-feed").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("moment-data/fda-510k-clearances-feed").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 '{}' |
apify call moment-data/fda-510k-clearances-feed --silent --output-dataset

```

## MCP server setup

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

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/4DItEuQFCW6lvdjPM/builds/6RwllTpjKWmb4C9zD/openapi.json