# FDA Device Clearance Records — 510(k) via openFDA (`nexgensignal/fda-device-clearance-records`) Actor

Per-record FDA 510(k) medical-device clearances from the official openFDA API. Applicant, device, product code, decision, dates, class. Keyless, public domain, no personal data.

- **URL**: https://apify.com/nexgensignal/fda-device-clearance-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 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/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 Device Clearance Records — 510(k) via openFDA

**Official source. No API key. Pay per record.**

This actor turns the U.S. FDA's **510(k) premarket notification** database into clean, per-clearance records — every medical-device market-entry decision, at the grain an organization tracks when it watches who is clearing what device and when. Each run reads the official openFDA `device/510k` endpoint and delivers one row per clearance: the 510(k) number, the applicant organization, the device name and product code, the decision and its dates, the device class and regulation, and the medical specialty — device and organization grain, with no applicant contact person, and openFDA's own accuracy disclaimer carried on every record.

### What this is, in one paragraph

Before most medical devices reach the U.S. market, their makers file a 510(k) premarket notification and the FDA issues a substantial-equivalence decision. openFDA publishes every one of these through a keyless API. This actor reads that endpoint, paginates within openFDA's published window, and flattens each clearance into a single analysis-ready row: who cleared a device, what it is, how it is classified, and when it was received and decided. Values are verbatim. You are billed only for records actually delivered.

### Who buys this and for what job

- **Medical-device companies and consultancies** tracking competitors' clearances by product code or specialty, and timing their own market entry.
- **Regulatory-affairs teams** monitoring what the FDA is clearing in their device category and how long decisions take.
- **Investors and market analysts** watching device market-entry activity across applicants and specialties.
- **Data engineers** who want a keyless, one-call feed of FDA device clearances already reduced to device/org fields.

### openFDA disclaimer (carried verbatim)

openFDA labels its data as unvalidated. This actor carries that disclaimer, exactly as published, on every record and in this listing:

> "Do not rely on openFDA to make decisions regarding medical care. While we make every effort to ensure that data is accurate, you should assume all results are unvalidated. We may limit or otherwise restrict your access to the API in line with our Terms of Service."

One more honest note travels on every record: a 510(k) clearance is a **substantial-equivalence decision, not an FDA endorsement or approval**. These are records for market-entry tracking — not medical, legal, or safety advice.

### Device / organization grain — no contact person

This actor works at device and organization grain: the clearance, the device, and the applicant company. The 510(k) record includes an applicant **contact** — a natural person — which this actor **never maps to a field**. As a second, structural safeguard, the device name is scrubbed before emit: the contact person's name (matched across whitespace variants, because the FDA data stores it with irregular spacing), and any email or phone-number pattern, are redacted. This is enforced by an acceptance test that feeds a clearance with a contact name, email, and phone embedded in the device name and asserts none survive, plus a live sweep over real clearances (100 clearances, 82 carrying a real contact person in the source → 0 emitted).

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `clearance_record` | $0.05 | $0.045 | $0.04 | $0.0335 |

Delivered before charged. Blocked runs and empty results cost nothing.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `productCode` | string | — | Optional 3-character FDA product code (e.g. `LPL`) to filter clearances. |
| `decisionSince` | string (YYYYMMDD) | — | Optional. Keep only clearances with a decision date on or after this date. |
| `maxRecords` | integer | 500 | Ceiling on records delivered and billed. |

The actor paces requests under openFDA's published rate limit.

### Output

One JSON object per clearance. Real example (values verbatim):

```json
{
  "record_id": "K142820",
  "k_number": "K142820",
  "applicant": "Abb Optical Group, LLC",
  "device_name": "BIOLENS Sphere (mangofilcon A) Soft (hydrophilic) Contact Lens for Daily Wear ...",
  "product_code": "LPL",
  "device_class": "2",
  "regulation_number": "886.5925",
  "medical_specialty": "Ophthalmic",
  "clearance_type": "Traditional",
  "decision_code": "SESE",
  "decision_description": "Substantially Equivalent",
  "decision_date": "2015-04-30",
  "date_received": "2014-09-30",
  "third_party_flag": "N",
  "applicant_city": "Coppell", "applicant_state": "TX", "applicant_country": "US",
  "source": "U.S. FDA openFDA (device/510k)",
  "source_url": "https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpmn/pmn.cfm?ID=K142820",
  "openfda_disclaimer": "Do not rely on openFDA ... assume all results are unvalidated ...",
  "licence": "U.S. FDA 510(k) ... public-domain U.S. Government data ...",
  "attribution": "Source: U.S. FDA via openFDA (device/510k).",
  "observed_at": "2026-08-19T00:00:00Z"
}
```

An unbilled `RUN_RECEIPT` records the robots check, the filters, the total matched, the disclaimer seen, records delivered, whether charged equals delivered, and whether the paging window was reached.

### Field reference

Each record is a flat set of market-entry fields. Identity: `record_id` / `k_number`. Who and what: `applicant` (organisation) and `device_name` (scrubbed of any contact). Classification: `product_code`, `device_class`, `regulation_number`, `medical_specialty`, and `advisory_committee_description`. The decision: `clearance_type`, `decision_code`, `decision_description`, `decision_date`, and `date_received`, plus the `third_party_flag`, `expedited_review_flag`, and `statement_or_summary` indicators. Where: `applicant_city`, `applicant_state`, and `applicant_country` — organisation location, never a person. Provenance and caveats: `source`, `source_url`, `openfda_disclaimer`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

A run first re-reads the source's robots posture from your runtime (the openFDA host serves no robots file, a no-policy posture) and stops at the door if that ever changes. It then builds a single filtered query from your product-code and decision-date inputs and reads the first page, recording openFDA's own `total` match count into the run receipt. Each clearance is flattened to one record — the applicant contact person dropped, the device name scrubbed — and delivered **before** it is charged, so a run that is blocked or finds nothing costs you nothing (an openFDA 404 is treated as a genuine-empty result, not an error). The actor pages through openFDA's bounded window, pacing between requests to stay within the published rate limit, and stops as soon as your `maxRecords` ceiling, the total match count, or the paging-window limit is reached — flagging that last case in the receipt so a truncated deep pull is never mistaken for full coverage. The `charge_equals_delivered` flag confirms you were billed for exactly what you received.

### Cost guidance

One `clearance_record` per delivered clearance: cost = clearances delivered × your plan's per-record price. The full 510(k) corpus is about **175,814 records**. openFDA serves a bounded paging window per query, so for deep historical pulls narrow with `productCode` or `decisionSince` — a single product code or a recent date range is typically a few hundred to a few thousand clearances. 1,000 clearances is **$50** (Free) / **$33.50** (Gold).

### Honest limitations

- **Unvalidated by the source.** openFDA states results are unvalidated; treat as informational and verify against the FDA 510(k) database.
- **Clearance ≠ approval.** A 510(k) is a substantial-equivalence decision, not FDA approval or endorsement.
- **Predicate device chains are not in the structured feed.** The 510(k) API does not expose predicate references (those live in the summary PDFs); this actor delivers the structured clearance record, not the predicate graph.
- **Bounded paging window.** Very deep pulls require a `productCode` or `decisionSince` filter; the run receipt flags when the window is reached.
- **No applicant contact-person data** is emitted, by design.

### Differentiation

Distinct from the sibling **fda-recall-risk-records**: recalls are devices (and foods/drugs) being pulled *off* the market — the opposite of clearances, which are devices *entering* it. Both are named so buyers pick the right one. It is also distinct from **fleet-1's fda-drug-approvals**: drugs are a different product class and a different FDA pathway than 510(k) devices. (The bank's drug-approvals candidate was deliberately not built, to avoid colliding with that fleet-1 product.)

### The NexGen Signal family

Part of the NexGen Signal family of official-source, pay-per-record products:

- [FDA Recall Risk Records — openFDA](https://apify.com/nexgensignal/fda-recall-risk-records)
- [Federal Rulemaking Records — US Federal Register](https://apify.com/nexgensignal/federal-rulemaking-records)
- [Grant Opportunity Records — US Grants.gov](https://apify.com/nexgensignal/grant-opportunity-records)
- [World Bank Project Records — Development Pipeline](https://apify.com/nexgensignal/world-bank-project-records)
- [Organization Sanctions & LEI Risk](https://apify.com/nexgensignal/organization-sanctions-lei-risk)

*Source: U.S. FDA via openFDA (device/510k). Public-domain U.S. Government data (https://open.fda.gov/license/). A 510(k) clearance is a substantial-equivalence decision, not an FDA approval or endorsement. Reformatted to device/organisation records; values verbatim; openFDA's "results are unvalidated" disclaimer carried on every record; no applicant contact-person data emitted.*

# Actor input Schema

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

Optional 3-character FDA product code (e.g. LPL) to filter clearances.

## `decisionSince` (type: `string`):

Optional. Keep only clearances with a decision date on or after this date.

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records delivered.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

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

The delivered FDA 510(k) clearance records.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/fda-device-clearance-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/fda-device-clearance-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/fda-device-clearance-records --silent --output-dataset

```

## MCP server setup

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

```

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/whV0BHVOWfvqm8sJS/builds/zGoUTz986iaBAtTPS/openapi.json