# openFDA Medical Device Events Scraper (`parseforge/openfda-device-event-scraper`) Actor

Export MAUDE medical-device adverse-event reports from openFDA. Search 24M+ reports by device name, manufacturer, event type, and event-date range. Pull report ID, device, manufacturer, event narrative, patient outcome, and dates.

- **URL**: https://apify.com/parseforge/openfda-device-event-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Other, Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $18.00 / 1,000 result items

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏥 openFDA Medical Device Events Scraper

> 🚀 **Export the official FDA medical-device safety dataset in seconds.** Pull **10,000,000+ MAUDE post-market reports** filtered by device, manufacturer, event type, or date range. No login, no daily quota juggling, no schema guesswork.

> 🕒 **Last updated:** 2026-05-22 · **📊 22 fields** per record · **🏥 10M+ device reports** · **🏭 thousands of manufacturers** · **🚨 every event type**

The **openFDA Medical Device Events Scraper** exports MAUDE (Manufacturer and User Facility Device Experience) post-market device adverse events and returns **22 fields per record**, including report identifiers, dates of event and receipt, device generic and brand names, manufacturer details, product problems, patient outcomes, and the full event narrative. MAUDE is the foundation of U.S. medical-device post-market surveillance.

The catalog covers **every device adverse-event report published by the FDA, from infusion pumps and insulin pumps to imaging systems and implants**. This Actor turns the live device safety feed into a downloadable dataset as CSV, Excel, JSON, or XML in under five minutes. Filtering happens at source, so you skip the paging and field-name spelunking entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Medtech QA and post-market surveillance teams, FDA compliance officers, recall researchers, device-safety analysts, biomedical engineers, health-tech investors, investigative journalists | Signal detection, post-market surveillance reports, competitor recall trackers, narrative-text mining, complaint-handling dashboards, investigative reporting on device safety |

---

### 📋 What the openFDA Medical Device Events Scraper does

Six filtering workflows in a single run:

- 🏥 **Device generic-name filter.** Restrict to one device category, e.g. INFUSION PUMP, INSULIN PUMP, CATHETER.
- 🏷️ **Brand-name filter.** Restrict to a device brand or trade name.
- 🏭 **Manufacturer filter.** Substring match on manufacturer company, e.g. MEDTRONIC, BAXTER, ABBOTT.
- 🚨 **Event-type filter.** Malfunction, Injury, Death, Other, or No answer provided.
- 📅 **Event-date from.** Lower bound on event date, format `YYYYMMDD`.
- 📅 **Event-date to.** Upper bound on event date, format `YYYYMMDD`.

Each record includes the report number, MDR key, event type, four dates (event, received, report, added), event location, product-problem flag and full problems list, report source, reporter country, manufacturer name and city, the full device array, patient outcomes, patient count, and the free-text event narrative.

> 💡 **Why it matters:** device safety signals hide in the narrative text. Building a parser yourself means handling decades of MAUDE submission drift, manufacturer name aliasing, and multi-patient structure. This Actor skips that work and keeps the dataset fresh on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded device-safety feed._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>deviceName</code></td><td>string</td><td><code>""</code></td><td>Device generic name (substring).</td></tr>
<tr><td><code>brandName</code></td><td>string</td><td><code>""</code></td><td>Device brand or trade name.</td></tr>
<tr><td><code>manufacturerName</code></td><td>string</td><td><code>""</code></td><td>Manufacturer company name (substring).</td></tr>
<tr><td><code>eventType</code></td><td>string</td><td><code>""</code></td><td>Malfunction, Injury, Death, Other, or No answer provided.</td></tr>
<tr><td><code>dateFrom</code></td><td>string</td><td><code>""</code></td><td>Lower bound on event date, format <code>YYYYMMDD</code>.</td></tr>
<tr><td><code>dateTo</code></td><td>string</td><td><code>""</code></td><td>Upper bound on event date, format <code>YYYYMMDD</code>.</td></tr>
</tbody>
</table>

**Example: 500 Medtronic infusion-pump injuries in 2024.**

```json
{
    "maxItems": 500,
    "deviceName": "INFUSION PUMP",
    "manufacturerName": "MEDTRONIC",
    "eventType": "Injury",
    "dateFrom": "20240101",
    "dateTo": "20241231"
}
````

**Example: every Death event for insulin pumps over a five-year window.**

```json
{
    "maxItems": 1000,
    "deviceName": "INSULIN PUMP",
    "eventType": "Death",
    "dateFrom": "20200101",
    "dateTo": "20241231"
}
```

> ⚠️ **Good to Know:** MAUDE submissions are voluntary for individuals and mandatory for manufacturers and device user facilities. A report does not establish causation, only that an event was observed and submitted. Treat the dataset as a signal source, not a clinical conclusion.

***

### 📊 Output

Each report record contains **22 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `reportNumber` | string | `"3007654321-2024-00012"` |
| 🆔 `mdrReportKey` | string | `"18234567"` |
| 🚨 `eventType` | string | `"Injury"` |
| 📅 `dateOfEvent` | string | null | `"20240312"` |
| 📅 `dateReceived` | string | `"20240320"` |
| 📅 `dateReport` | string | null | `"20240315"` |
| 📅 `dateAdded` | string | `"20240325"` |
| 📅 `dateChanged` | string | null | `"20240326"` |
| 📍 `eventLocation` | string | null | `"HOSPITAL"` |
| ⚠️ `productProblemFlag` | string | `"Y"` |
| 🔧 `productProblems` | array | `["Infusion or Flow Issue"]` |
| 📥 `reportSource` | array | `["Manufacturer"]` |
| 🌍 `reporterCountry` | string | `"US"` |
| 🏭 `manufacturerName` | string | `"MEDTRONIC MINIMED"` |
| 🏙️ `manufacturerCity` | string | `"NORTHRIDGE"` |
| 📋 `typeOfReport` | array | `["Initial"]` |
| 🏥 `devices` | array | `[{"generic_name": "INFUSION PUMP", "brand_name": "...", ...}]` |
| 👤 `patientCount` | number | `1` |
| 👤 `patients` | array | `[{"patient_age": "64", "sequence_number_outcome": ["Required Intervention"]}]` |
| 📝 `eventText` | string | null | `"It was reported that the device alarmed and stopped..."` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |
| ⚠️ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>💉 Infusion-pump injury report</strong></summary>

```json
{
    "reportNumber": "3007654321-2024-00012",
    "eventType": "Injury",
    "dateOfEvent": "20240312",
    "dateReceived": "20240320",
    "productProblemFlag": "Y",
    "productProblems": ["Infusion or Flow Issue"],
    "reporterCountry": "US",
    "manufacturerName": "MEDTRONIC MINIMED",
    "manufacturerCity": "NORTHRIDGE",
    "patientCount": 1,
    "eventText": "It was reported that the device alarmed and stopped delivering insulin...",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>☠️ Fatal device event</strong></summary>

```json
{
    "reportNumber": "1234567890-2024-00099",
    "eventType": "Death",
    "dateOfEvent": "20240515",
    "dateReceived": "20240530",
    "productProblemFlag": "Y",
    "productProblems": ["Failure to Deliver"],
    "reporterCountry": "US",
    "manufacturerName": "ABBOTT",
    "patientCount": 1,
    "eventText": "Patient was found unresponsive. Device log indicated failure to deliver...",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🔧 Malfunction without injury</strong></summary>

```json
{
    "reportNumber": "9876543210-2024-00045",
    "eventType": "Malfunction",
    "dateOfEvent": "20240618",
    "dateReceived": "20240625",
    "productProblemFlag": "Y",
    "productProblems": ["Device Operates Differently Than Expected"],
    "reporterCountry": "DE",
    "manufacturerName": "BAXTER HEALTHCARE",
    "patientCount": 0,
    "eventText": "The device displayed an error code during routine use. No patient harm reported...",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏥 | **Full MAUDE coverage.** 10M+ post-market device adverse-event reports across decades of submissions. |
| 🎯 | **Multi-dimensional filtering.** Device, brand, manufacturer, event type, and date range compose freely in a single run. |
| 📝 | **Full event narratives.** Free-text descriptions on every record, ready for NLP and signal detection. |
| 🏭 | **Manufacturer details.** Name plus city for cross-reference with corporate records. |
| ⚡ | **Fast.** 10 reports in under 5 seconds, 10,000 in under five minutes. |
| 🔁 | **Always fresh.** Every run pulls live MAUDE data published by the FDA. |
| 🚫 | **No authentication.** Works with the public openFDA dataset. No token or quota required from you. |

> 📊 Device-event surveillance is the foundation of every modern medtech quality system, complaint-handling pipeline, and post-market study.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ openFDA Medical Device Events Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **10M+** reports worldwide | **Live per run** | device, brand, manufacturer, event type, date | ⚡ 2 min |
| Commercial post-market suites | $50k+/year per seat | Curated, scored | Daily | Many | ⏳ Weeks |
| Manual MAUDE quarterly downloads | Free | Bulk only, lagging | Quarterly | Local parsing | 🐢 Days |
| Building your own ingestion | Engineering cost | Brittle | Breaks on schema drift | Custom | 🕒 Weeks |

Pick this Actor when you want clean structured MAUDE records, server-side filters, and zero pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the openFDA Medical Device Events Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a device, manufacturer, event type, or date range, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🛡️ Medtech QA and post-market surveillance

- Quarterly safety updates per device line
- Competitor recall and malfunction trackers
- Signal detection on injury or death clusters
- Narrative-text mining for emerging issues

</td>
<td width="50%" valign="top">

#### ⚖️ FDA compliance and regulatory affairs

- Pre-submission research on similar devices
- Post-market reporting evidence
- Periodic Safety Update inputs
- Inspection-ready trail of source records

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🩺 Hospital biomedical engineering

- Device-acquisition risk reviews
- Internal benchmarks of device families
- Investigations of in-house complaints
- Vendor-comparison reports for procurement

</td>
<td width="50%" valign="top">

#### 📰 Health journalism and recall research

- Reproducible investigations into device safety
- Coverage of high-profile recalls
- Comparisons across manufacturers
- Public-interest reporting on long-running issues

</td>
</tr>
</table>

***

### 🔌 Automating openFDA Medical Device Events Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily or weekly refreshes keep downstream complaint-handling pipelines in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Biomedical-engineering coursework on safety analysis
- Replication studies on device-malfunction clusters
- Master's and PhD theses on post-market mining
- Cross-source studies linking MAUDE to literature

</td>
<td width="50%">

#### 🎨 Personal and creative

- Patient-advocacy newsletters on device safety
- Personal trackers for an implanted device class
- Public visualizations of long-term trends
- Blog posts on recall histories

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Patient-safety nonprofits monitoring device classes
- Civic transparency on recall cycles
- Investigative journalism on under-reported events
- Public-health agencies tracking regional clusters

</td>
<td width="50%">

#### 🧪 Experimentation

- Train event-type classifiers on narratives
- Build LLM agents that summarize device safety profiles
- Prototype anomaly detection on time-series reports
- Validate medical-NLP pipelines against real records

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20openFDA%20Medical%20Device%20Events%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20openFDA%20Medical%20Device%20Events%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20openFDA%20Medical%20Device%20Events%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20openFDA%20Medical%20Device%20Events%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Set a device, manufacturer, event type, or date range in the input form, click Start, and the Actor queries the official FDA device-safety dataset and emits a clean structured record per report. No browser automation, no captchas, no setup.

#### 📏 How accurate is the data?

The dataset is sourced directly from the FDA MAUDE catalog. Submission quality varies because reports come from manufacturers, user facilities, and individual reporters. Treat the records as raw signals, not adjudicated outcomes.

#### 🔁 How often is the dataset refreshed?

The FDA refreshes the dataset on an ongoing basis. Every run of this Actor fetches the latest data, so your output reflects current records as of run time.

#### 📅 What date range is covered?

Records reach back over two decades. Use the `dateFrom` and `dateTo` inputs to scope any window down to the day.

#### 🚨 What does each event type mean?

Malfunction covers a device failure without confirmed patient harm. Injury covers cases where a device may have caused or contributed to a non-fatal injury. Death covers fatalities. Other and No answer provided cover residual cases.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (daily, weekly, monthly) and keep a downstream complaint-handling dashboard in sync.

#### ⚖️ Is this data legal to use?

Yes. MAUDE is published by the U.S. FDA under a permissive open-data policy. Review downstream regulatory requirements for your specific use case.

#### 💼 Can I use this data commercially?

Yes. Open FDA records are publicly available for commercial reuse. You are responsible for any downstream regulatory or labeling obligations.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

openFDA Medical Device Events Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get device-safety alerts in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe device-event data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh device-event data into your complaint-handling system, or alert your team in Slack on new serious reports.

***

### 🔗 Recommended Actors

- [**💊 openFDA Drug Adverse Events Scraper**](https://apify.com/parseforge/openfda-drug-events-scraper) - FAERS post-market drug safety reports
- [**💊 openFDA Drug NDC Directory Scraper**](https://apify.com/parseforge/openfda-drug-ndc-scraper) - Marketed drug products with NDC, ingredients, and labelers
- [**📋 Drugs@FDA Approvals Scraper**](https://apify.com/parseforge/openfda-drugsfda-scraper) - NDA, ANDA, and BLA approval records
- [**🧪 ClinicalTrials.gov Scraper**](https://apify.com/parseforge/clinicaltrials-gov-scraper) - Clinical trial registrations and results
- [**🩺 Florida MQA License Scraper**](https://apify.com/parseforge/florida-mqa-scraper) - U.S. healthcare practitioner license records

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more healthcare and life-sciences scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the U.S. Food and Drug Administration. All trademarks mentioned are the property of their respective owners. Only publicly available openFDA records are collected. Safety reports do not establish causation and should not be interpreted as clinical conclusions.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `deviceName` (type: `string`):

Generic device name (substring), e.g. INFUSION PUMP, INSULIN PUMP, CATHETER.

## `brandName` (type: `string`):

Device brand / trade name.

## `manufacturerName` (type: `string`):

Device manufacturer name (substring), e.g. MEDTRONIC, BAXTER, ABBOTT.

## `eventType` (type: `string`):

Severity classification of the event.

## `dateFrom` (type: `string`):

Lower bound on the event date. Format: YYYYMMDD. Example: 20200101.

## `dateTo` (type: `string`):

Upper bound on the event date. Format: YYYYMMDD. Example: 20231231.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/openfda-device-event-scraper").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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/openfda-device-event-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/openfda-device-event-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/openfda-device-event-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "openFDA Medical Device Events Scraper",
        "description": "Export MAUDE medical-device adverse-event reports from openFDA. Search 24M+ reports by device name, manufacturer, event type, and event-date range. Pull report ID, device, manufacturer, event narrative, patient outcome, and dates.",
        "version": "1.0",
        "x-build-id": "fXWcWiqOtUgLRV6lB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~openfda-device-event-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-openfda-device-event-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~openfda-device-event-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-openfda-device-event-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~openfda-device-event-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-openfda-device-event-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "deviceName": {
                        "title": "Device Generic Name",
                        "type": "string",
                        "description": "Generic device name (substring), e.g. INFUSION PUMP, INSULIN PUMP, CATHETER."
                    },
                    "brandName": {
                        "title": "Device Brand Name",
                        "type": "string",
                        "description": "Device brand / trade name."
                    },
                    "manufacturerName": {
                        "title": "Manufacturer Name",
                        "type": "string",
                        "description": "Device manufacturer name (substring), e.g. MEDTRONIC, BAXTER, ABBOTT."
                    },
                    "eventType": {
                        "title": "Event Type",
                        "enum": [
                            "",
                            "Malfunction",
                            "Injury",
                            "Death",
                            "Other",
                            "No answer provided"
                        ],
                        "type": "string",
                        "description": "Severity classification of the event."
                    },
                    "dateFrom": {
                        "title": "Event Date From (YYYYMMDD)",
                        "pattern": "^[0-9]{8}$",
                        "type": "string",
                        "description": "Lower bound on the event date. Format: YYYYMMDD. Example: 20200101."
                    },
                    "dateTo": {
                        "title": "Event Date To (YYYYMMDD)",
                        "pattern": "^[0-9]{8}$",
                        "type": "string",
                        "description": "Upper bound on the event date. Format: YYYYMMDD. Example: 20231231."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
