# FDA MAUDE, 510(k) & Warning Letters Scraper and Alerts (`radiant_opuntia/fda-compliance-alerts`) Actor

Track FDA 510(k) device clearances, MAUDE adverse event reports (deaths, injuries, malfunctions) and warning letters from fda.gov in one Actor. Filter by device, company, product code or FDA office. 'Only new' mode for daily regulatory alerts. No API key, no login.

- **URL**: https://apify.com/radiant_opuntia/fda-compliance-alerts.md
- **Developed by:** [GovData Feeds](https://apify.com/radiant_opuntia) (community)
- **Categories:** Automation, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 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?

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

**Track FDA medical device clearances (510(k)), MAUDE adverse event reports and FDA warning letters as clean rows, with new-record alerts.**

**Rate your experience:** if you have used this Actor, you can tell us how it went on the [reviews page](https://apify.com/radiant_opuntia/fda-compliance-alerts/reviews). Honest feedback of any kind helps us improve it.

### What it does and who it is for

One Actor, three FDA datasets, selected with the **Dataset** input: **510(k)** (new device clearance decisions, from openFDA), **MAUDE** (medical device adverse event, malfunction and death reports, from openFDA) and **Warning letters** (the FDA warning letter listing on fda.gov). Each record has a common core (`dataset`, `recordId`, `date`, `company`, `title`, `category`, `productCode`, `url`) plus fields specific to the dataset.

Filter by keyword, company, FDA product code and date window, plus dataset-specific filters: decision and clearance type and applicant state for 510(k), event type for MAUDE, and issuing office for warning letters. Turn on **Only new** for alerts.

#### Use cases

- **Medical device makers and regulatory teams:** watch competitor clearances and adverse event reports in your product code.
- **Investors and analysts:** follow clearances and warning letters for listed device and drug companies.
- **Quality, safety and compliance teams:** track warning letters and MAUDE reports for suppliers.
- **Consultants, law firms and journalists:** a daily or weekly feed of FDA enforcement and clearance activity.
- **AI agents:** answer "which companies got a new 510(k) clearance for insulin pumps this month?".

### Why use this instead of the free official site or API

The underlying data is public and the official sources are free. What this Actor adds is convenience: three different FDA sources become one consistent, alert-ready feed.

| What you need | Official site / API | This Actor |
|---|---|---|
| Covering clearances, adverse events and warning letters | Separate openFDA endpoints plus a warning-letter listing page with no API of its own | One Actor and one input; choose the dataset |
| Query syntax | openFDA search syntax and paging limits | Plain input fields: keyword, company, product code, dates |
| Days to decision | Subtract received and decision dates yourself | `daysToDecision` calculated on every 510(k) record |
| Only new records | You track IDs yourself | **Only new** mode with a named alert |

If you only need a single lookup now and then, the official site is fine. If you want the same data on a schedule, as flat rows you can feed to a spreadsheet, CRM or agent, this saves the glue work.

### Data fields

The table shows the 510(k) record from the example below, followed by fields that only appear for **MAUDE** and **Warning letters** records. Every record also has `dataset` telling you which one it is.

| Field | Type | What it contains |
|---|---|---|
| `dataset` | text | 510k, maude or warning_letters. |
| `recordId` | text | 510(k): K number. MAUDE: MDR report key. Warning letters: the letter's slug on fda.gov. |
| `date` | date | 510(k): decision date. MAUDE: date received. Warning letters: posted date. |
| `company` | text | 510(k): applicant. MAUDE: manufacturer. Warning letters: company name. |
| `title` | text | 510(k): device name. MAUDE: brand or generic name. Warning letters: letter subject. |
| `category` | text | 510(k): decision description. MAUDE: event type. Warning letters: issuing office. |
| `decisionCode` | text | 510(k) only: decision code (for example SESE for Substantially Equivalent). |
| `clearanceType` | text | 510(k) only: Traditional, Special, Abbreviated, Direct or Dual Track. |
| `dateReceived` | date | 510(k) only: date FDA received the submission. |
| `daysToDecision` | integer | 510(k) only: days between receipt and decision. |
| `productCode` | text | Three-letter FDA product code. |
| `deviceClass` | text | FDA device class (510(k) and MAUDE). |
| `regulationNumber` | text | 510(k) only: regulation number. |
| `medicalSpecialty` | text | 510(k) only: medical specialty or advisory committee. |
| `statementOrSummary` | text | 510(k) only: whether a Statement or a Summary was filed. |
| `thirdPartyReview` | boolean | 510(k) only: whether a third party reviewed it. |
| `expeditedReview` | text | 510(k) only: expedited review flag, when given. |
| `contact` | text | 510(k) only: applicant contact name. |
| `address` | text | 510(k) only: applicant street address. |
| `city` | text | 510(k) only: applicant city. |
| `state` | text | 510(k) only: applicant state. |
| `zip` | text | 510(k) only: applicant ZIP or postal code. |
| `country` | text | 510(k) only: applicant country code. |
| `url` | text | Link to the record on FDA's site. |
| `source` | text | Source of the data. |
| `scrapedAt` | datetime | When the Actor collected the record (UTC). |
| `reportNumber` | text | MAUDE only: manufacturer report number. |
| `dateOfEvent` | date | MAUDE only: date the event occurred. |
| `genericName` | text | MAUDE only: generic device name. |
| `model` | text | MAUDE only: model number. |
| `catalogNumber` | text | MAUDE only: catalog number. |
| `lotNumber` | text | MAUDE only: lot number. |
| `deviceManufacturer` | text | MAUDE only: device manufacturer name. |
| `reportType` | text | MAUDE only: report type. |
| `reportSource` | text | MAUDE only: report source. |
| `productProblems` | text | MAUDE only: product problems. |
| `patientOutcomes` | text | MAUDE only: patient outcomes. |
| `patientProblems` | text | MAUDE only: patient problems. |
| `devicesInEvent` | integer | MAUDE only: number of devices in the event. |
| `patientsInEvent` | integer | MAUDE only: number of patients in the event. |
| `narrative` | text | MAUDE only: the first up to 1,500 characters of the event description (when **Include narrative** is on). |
| `letterIssueDate` | date | Warning letters only: date the letter was issued. |
| `issuingOffice` | text | Warning letters only: FDA office that issued it. |
| `subject` | text | Warning letters only: letter subject. |
| `marcsCmsNumber` | text | Warning letters only: MARCS-CMS number from the letter URL, when present. |
| `responseLetter` | boolean | Warning letters only: whether a response letter is listed. |
| `closeoutLetter` | boolean | Warning letters only: whether a close-out letter is listed. |

Fields a source does not publish are `null`.

### "New since yesterday" alerts

Turn on **Only new** and the Actor remembers what it has already returned, so each scheduled run delivers only records you have not seen before.

1. Open the Actor in Apify Console and set the input, with **Only new since last run** switched on and a fixed alert name (`stateKey`). Example input:

```json
{
  "dataset": "maude",
  "keyword": "insulin pump",
  "eventTypes": ["Death", "Injury"],
  "postedWithinDays": 45,
  "includeNarrative": true,
  "maxResults": 200,
  "onlyNew": true,
  "stateKey": "insulin-pump-adverse-events"
}
```

2. Click **Save as task**, then open **Schedules**, create a schedule (for example the cron expression `0 7 * * *` for every day at 7:00 in the time zone you pick) and add the task to it.
3. Under the task's **Integrations**, send the results to Slack, email, Google Sheets, a webhook or your own system.

MAUDE is published about monthly, so use a window of 45 days or more for MAUDE. For 510(k) clearances 30 days is plenty, because openFDA publishes them weekly.

The first run returns everything that matches your window (all matching records in the window); later runs return only unseen records. Use a different alert name for each task so each keeps its own memory. A run with nothing new returns no results.

### Cost per run

This Actor uses **pay-per-result pricing: $3.00 per 1,000 results ($0.003 per result)**, with the Apify platform fee included. You are charged for the records a run returns and nothing is added on top for platform usage. A run that finds nothing new returns no results, so it has no per-result charge. The **Max results** input caps what a run can return (and so what it can cost).

**Worked example:** a weekly 510(k) alert returning 40 new clearances costs 40 × $0.003 = $0.12 per run. A pull of 2,000 MAUDE reports costs 2 × $3.00 = $6.00.

The pricing is configured in Apify Console; the Pricing tab on this page is the authoritative source if it ever differs from this text.

### Example input and output

The output below comes from real test runs of this Actor. This example shows a 510(k) record; MAUDE and warning letter records have the extra fields listed above. Email addresses are masked and very long text is shortened here; the Actor returns the full values.

Input used for the example:

```json
{
  "dataset": "510k",
  "keyword": "catheter",
  "postedWithinDays": 60,
  "clearanceTypes": ["Traditional"],
  "onlyNew": true,
  "stateKey": "new-catheter-clearances",
  "maxResults": 3
}
```

Output (the first 2 records of a test run):

```json
[
  {
    "dataset": "510k",
    "recordId": "K262068",
    "date": "2026-10-09",
    "company": "CathRx, Ltd.",
    "title": "Khelix Magnetic Sensor Electrophysiology Catheter (SS1-*-*-MAG)",
    "category": "Substantially Equivalent",
    "decisionCode": "SESE",
    "clearanceType": "Traditional",
    "dateReceived": "2026-06-22",
    "daysToDecision": 109,
    "productCode": "DRF",
    "deviceClass": "2",
    "regulationNumber": "870.1220",
    "medicalSpecialty": "Cardiovascular",
    "statementOrSummary": "Summary",
    "thirdPartyReview": false,
    "expeditedReview": null,
    "contact": "Henry Le",
    "address": "Unit 8, 2-8 S. St.",
    "city": "Rydalmere",
    "state": null,
    "zip": "2116",
    "country": "AU",
    "url": "https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpmn/pmn.cfm?ID=K262068",
    "source": "openFDA device/510k",
    "scrapedAt": "2026-10-23T12:43:25.105Z"
  },
  {
    "dataset": "510k",
    "recordId": "K261649",
    "date": "2026-10-09",
    "company": "Stryker Neurovascular",
    "title": "Excelsior Reach Microcatheter",
    "category": "Substantially Equivalent",
    "decisionCode": "SESE",
    "clearanceType": "Traditional",
    "dateReceived": "2026-05-19",
    "daysToDecision": 143,
    "productCode": "QJP",
    "deviceClass": "2",
    "regulationNumber": "870.1250",
    "medicalSpecialty": "Cardiovascular",
    "statementOrSummary": "Summary",
    "thirdPartyReview": false,
    "expeditedReview": null,
    "contact": "Katelynn Kirby",
    "address": "47900 Bayside Pkwy.",
    "city": "Fremont",
    "state": "CA",
    "zip": "94538",
    "country": "US",
    "url": "https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpmn/pmn.cfm?ID=K261649",
    "source": "openFDA device/510k",
    "scrapedAt": "2026-10-23T12:43:25.111Z"
  }
]
```

### Limits worth knowing

- **MAUDE data is about 3 to 4 weeks behind.** Use a look-back of at least 45 days for MAUDE.
- openFDA publishes 510(k) data weekly.
- The warning letter listing has listing fields only: there is no letter text. The Actor depends on the layout of the fda.gov warning letters page, so a page redesign could break that dataset.
- MAUDE event narratives are cut at 1,500 characters.
- openFDA returns an error when nothing matches; the Actor handles that and returns no results.
- For recalls, use the separate FDA recall Actor below; this one does not return recalls.
- With a small **Max results** and Only new on, each run returns the next unseen batch.

### FAQ

#### What is a 510(k)?

A premarket notification that device makers submit to FDA to show a device is substantially equivalent to one already on the market. The dataset lists FDA's decisions.

#### What is MAUDE?

The FDA database of medical device adverse event, malfunction and death reports. Reports are submitted by manufacturers, clinicians and consumers; an entry does not prove the device caused the event.

#### Do I need an API key?

No.

#### Does it include the text of warning letters?

No. It returns the listing fields and the link to the letter on fda.gov.

#### Is this the same as FDA recalls?

No. See the FDA recall Actor below.

### Related Actors

More Actors from GovData Feeds, all on Apify:

- [sam-gov-opportunities-alerts](https://apify.com/radiant_opuntia/sam-gov-opportunities-alerts): New SAM.gov federal contract opportunities and bid alerts
- [grants-gov-alerts](https://apify.com/radiant_opuntia/grants-gov-alerts): US federal grant opportunities (Grants.gov): ceilings, deadlines, eligibility
- [sec-form-d-alerts](https://apify.com/radiant_opuntia/sec-form-d-alerts): SEC Form D filings: companies that just raised money
- [usaspending-awards-alerts](https://apify.com/radiant_opuntia/usaspending-awards-alerts): New federal contract, grant and loan awards (USAspending)
- [sec-form4-insider-alerts](https://apify.com/radiant_opuntia/sec-form4-insider-alerts): SEC Form 4 insider buys and sells, one row per transaction
- [fda-recall-alerts](https://apify.com/radiant_opuntia/fda-recall-alerts): FDA food, drug and medical device recalls
- [cpsc-recall-alerts](https://apify.com/radiant_opuntia/cpsc-recall-alerts): CPSC consumer product safety recalls
- [us-building-permits-alerts](https://apify.com/radiant_opuntia/us-building-permits-alerts): New building permits from nine city open-data portals
- [clinical-trials-alerts](https://apify.com/radiant_opuntia/clinical-trials-alerts): New ClinicalTrials.gov studies by condition, sponsor and phase
- [federal-register-alerts](https://apify.com/radiant_opuntia/federal-register-alerts): Federal Register rules, proposed rules and notices
- [contractor-license-alerts](https://apify.com/radiant_opuntia/contractor-license-alerts): New contractor licenses in WA, OR and NY with bond and insurance
- [ofac-sanctions-alerts](https://apify.com/radiant_opuntia/ofac-sanctions-alerts): OFAC sanctions screening and change alerts
- [new-business-registrations-alerts](https://apify.com/radiant_opuntia/new-business-registrations-alerts): New LLC and corporation registrations (NY, CO, OR, CT)
- [epa-echo-enforcement-alerts](https://apify.com/radiant_opuntia/epa-echo-enforcement-alerts): EPA ECHO facilities with new environmental penalties
- [restaurant-inspections-alerts](https://apify.com/radiant_opuntia/restaurant-inspections-alerts): Restaurant health inspections from seven US jurisdictions
- [code-violations-alerts](https://apify.com/radiant_opuntia/code-violations-alerts): Building, housing and property code violations from six cities

*Data comes from openFDA and fda.gov, a US government source. This Actor is not affiliated with or endorsed by the FDA. MAUDE reports are unverified and do not establish that a device caused an event. Always confirm on the official FDA record.*

# Actor input Schema

## `dataset` (type: `string`):

510(k) = new FDA device clearances (decisions). MAUDE = adverse event / malfunction / death reports on medical devices. Warning letters = FDA enforcement letters to drug, device, food, cosmetic and tobacco firms.

## `keyword` (type: `string`):

510(k): matches the device name. MAUDE: matches the brand or generic device name. Warning letters: matches the company name or the violation subject (e.g. 'CGMP', 'Adulterated', 'Unapproved').

## `company` (type: `string`):

510(k): applicant. MAUDE: manufacturer. Warning letters: company name. Example: 'Medtronic'.

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

Three-letter FDA product codes, e.g. 'DSP' (intra-aortic balloon pump) or 'QFG' (insulin pump controller). Leave empty for all.

## `postedWithinDays` (type: `integer`):

Only records with a decision / received / posted date in the last N days. Note: openFDA publishes 510(k) weekly and MAUDE about monthly, so use 30+ days for MAUDE. Ignored if a start date is set.

## `startDate` (type: `string`):

YYYY-MM-DD. Overrides the look back.

## `endDate` (type: `string`):

YYYY-MM-DD. Leave empty for today.

## `decisions` (type: `array`):

Only for 510(k). SESE = Substantially Equivalent. Leave empty for all.

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

Only for 510(k).

## `applicantState` (type: `string`):

Two-letter US state of the 510(k) applicant, e.g. 'MN'. Leave empty for all.

## `eventTypes` (type: `array`):

Only for MAUDE. Leave empty for all.

## `issuingOffices` (type: `array`):

Only warning letters from FDA offices whose name contains one of these words, e.g. 'CDRH' (devices), 'CDER' (drugs), 'Human Foods', 'Tobacco'. Leave empty for all.

## `includeNarrative` (type: `boolean`):

Include the first part of the event description text for MAUDE reports (up to 1,500 characters).

## `onlyNew` (type: `boolean`):

Skip records already returned by a previous run with the same alert name. Use this for daily alerts.

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

Name this alert so each saved search tracks its own history, e.g. 'device-deaths'. Leave empty to derive it from the search.

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

Maximum number of records to return in one run.

## Actor input object example

```json
{
  "dataset": "510k",
  "keyword": "",
  "company": "",
  "productCodes": [],
  "postedWithinDays": 30,
  "startDate": "",
  "endDate": "",
  "decisions": [],
  "clearanceTypes": [],
  "applicantState": "",
  "eventTypes": [],
  "issuingOffices": [],
  "includeNarrative": true,
  "onlyNew": false,
  "stateKey": "",
  "maxResults": 50
}
```

# Actor output Schema

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

All FDA record records returned by this run (flat JSON items in the default dataset).

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

Counts of items pushed and items skipped as already seen (only-new mode).

# 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 = {
    "dataset": "510k",
    "keyword": "",
    "company": "",
    "postedWithinDays": 30,
    "startDate": "",
    "endDate": "",
    "applicantState": "",
    "includeNarrative": true,
    "onlyNew": false,
    "stateKey": "",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("radiant_opuntia/fda-compliance-alerts").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 = {
    "dataset": "510k",
    "keyword": "",
    "company": "",
    "postedWithinDays": 30,
    "startDate": "",
    "endDate": "",
    "applicantState": "",
    "includeNarrative": True,
    "onlyNew": False,
    "stateKey": "",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("radiant_opuntia/fda-compliance-alerts").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 '{
  "dataset": "510k",
  "keyword": "",
  "company": "",
  "postedWithinDays": 30,
  "startDate": "",
  "endDate": "",
  "applicantState": "",
  "includeNarrative": true,
  "onlyNew": false,
  "stateKey": "",
  "maxResults": 50
}' |
apify call radiant_opuntia/fda-compliance-alerts --silent --output-dataset

```

## MCP server setup

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

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/DNjYKQnjCSYqCN8Qc/builds/m3HbEhbqEd7TQSdry/openapi.json
