# FDA Adverse Events (FAERS) Scraper — Drug Safety Reports (`compute-edge/fda-adverse-events-scraper`) Actor

Extract drug adverse event reports from the FDA FAERS database via openFDA API. Filter by drug name, reaction, severity, and date. Zero auth required.

- **URL**: https://apify.com/compute-edge/fda-adverse-events-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## FDA Adverse Events (FAERS) Scraper — Drug Safety Reports

Extract structured drug adverse event data from the **FDA Adverse Event Reporting System (FAERS)** via the free, public **openFDA API**. This Actor lets you search across more than **20 million adverse event reports** submitted to the FDA since 1968 — no API key, no authentication, no subscription required.

FAERS is the FDA's primary pharmacovigilance database. Healthcare professionals, patients, and manufacturers report suspected drug side effects, medication errors, and product quality problems. The database is used by the FDA for post-market safety surveillance, by pharmaceutical companies for regulatory compliance, by researchers for drug safety studies, and increasingly by litigation teams investigating drug-related injuries.

This Actor flattens the nested FAERS report structure into clean, analyst-ready JSON — no deep parsing required. Filter by drug name, MedDRA reaction term, report severity, and date range. Export to CSV or Excel for direct use in statistical tools or BI dashboards.

### What Data Does This Actor Extract?

| Field | Description |
|-------|-------------|
| `safetyReportId` | Unique FDA safety report identifier |
| `receiveDate` | Date FDA received the report (YYYY-MM-DD) |
| `drugs` | Semicolon-separated list of all drugs in the report |
| `primaryDrugCharacterization` | The suspect drug most likely causing the reaction |
| `indications` | Reported therapeutic indications for each drug |
| `reactions` | Semicolon-separated MedDRA adverse reaction terms |
| `reactionOutcomes` | Outcomes per reaction (Recovered, Fatal, etc.) |
| `serious` | Whether the report was flagged as serious (boolean) |
| `seriousnessDeath` | Whether death was reported as an outcome (boolean) |
| `seriousnessHospitalization` | Whether hospitalization was required (boolean) |
| `patientSex` | Patient sex: Male, Female, or Unknown |
| `patientAge` | Patient age with unit (e.g., "45 year(s)") |
| `occurCountry` | Country where the adverse event occurred |

### Features

- Filter by drug name, adverse reaction, severity, and date range
- Zero authentication required — uses the public openFDA API
- Returns structured, flattened JSON (no nested objects to parse)
- Pagination up to 25,000 records per run (openFDA's hard limit)
- Empty-input mode returns recent reports across all drugs and reactions
- Handles missing or malformed fields gracefully

### How to Scrape FDA Adverse Event Reports

1. Open the **FDA Adverse Events Scraper** on the Apify Store and click **Try for free**.
2. In the **Drug Name** field, enter the drug you want to research (e.g., `ASPIRIN`, `IBUPROFEN`, `ATORVASTATIN`). Leave blank to pull all recent reports.
3. Optionally enter an **Adverse Reaction** MedDRA term to narrow results (e.g., `NAUSEA`, `CARDIAC ARREST`, `DEATH`).
4. Toggle **Serious Reports Only** to restrict results to hospitalizations, deaths, and life-threatening events.
5. Set a **Date From** and **Date To** to restrict the date range (YYYY-MM-DD format).
6. Set **Maximum Results** to control the output size (default: 1,000; max: 25,000).
7. Click **Start** and wait for the run to complete (typically under 60 seconds for 1,000 records).
8. Download results as JSON, CSV, or Excel from the **Dataset** tab.

### Input Example

```json
{
    "drugName": "ASPIRIN",
    "reaction": "NAUSEA",
    "seriousOnly": false,
    "dateFrom": "2023-01-01",
    "dateTo": "2023-12-31",
    "maxResults": 500
}
````

### Output Example

```json
{
    "safetyReportId": "US-BAYER-2023-12345",
    "serious": true,
    "seriousnessDeath": false,
    "seriousnessHospitalization": true,
    "receiveDate": "2023-04-15",
    "occurCountry": "US",
    "patientSex": "Female",
    "patientAge": "67 year(s)",
    "drugs": "ASPIRIN; LISINOPRIL",
    "indications": "PAIN; HYPERTENSION",
    "reactions": "NAUSEA; GASTROINTESTINAL HAEMORRHAGE",
    "reactionOutcomes": "Recovered/Resolved; Recovering/Resolving",
    "primaryDrugCharacterization": "ASPIRIN"
}
```

### Pricing

This Actor calls the free openFDA API with no browser overhead. Compute costs are very low.

- **Per-result pricing**: $0.003/result
- **Typical run**: 1,000 records in under 60 seconds
- **Cost estimate**: ~$3 in Actor fees for 1,000 records plus minimal Apify platform compute

### Use Cases

- **Pharmacovigilance research** — Identify adverse event signals for specific drugs or drug classes
- **Drug safety analysis** — Compare serious event rates across similar medications
- **Regulatory compliance** — Monitor FAERS submissions for a specific product or therapeutic area
- **Litigation support** — Pull historical adverse event reports for a drug under legal scrutiny
- **Competitive intelligence** — Compare safety profiles of branded vs. generic equivalents
- **Academic research** — Build datasets for epidemiology, signal detection, or NLP studies
- **RAG pipeline ingestion** — Feed structured adverse event data into AI safety monitoring systems

### FAQ

**Q: Do I need an FDA API key?**
A: No. The openFDA API is free and public. No registration or API key is required for standard usage.

**Q: How many records can I get per run?**
A: Up to 25,000 per run. This is a hard limit enforced by the openFDA API's pagination cap. For larger datasets, consider splitting by date range across multiple runs.

**Q: How current is the FAERS data?**
A: FAERS data is updated quarterly by the FDA. The most recent quarter's data is typically available within 3–4 months of the reporting period.

**Q: Can I filter by multiple drugs at once?**
A: Currently one drug name per run. For multiple drugs, run the Actor multiple times (once per drug) and merge the output datasets.

**Q: What are MedDRA terms?**
A: MedDRA (Medical Dictionary for Regulatory Activities) is the standardized terminology used by the FDA and pharmaceutical industry to classify adverse events. Examples: `NAUSEA`, `MYOCARDIAL INFARCTION`, `ANAPHYLACTIC REACTION`. Use exact MedDRA terms in the reaction field for precise filtering.

**Q: Why do some records have empty drug names or reactions?**
A: FAERS submissions are voluntary and often incomplete. The Actor passes through whatever the FDA received — missing fields are returned as empty strings.

### Other Actors by SeatSignal

- [CISA KEV Scraper](https://apify.com/seatsignal/cisa-kev-scraper) — Extract CISA Known Exploited Vulnerabilities catalog
- Check our full portfolio of government data and regulatory scrapers on the Apify Store

### Legal Disclaimer

This Actor uses the public openFDA API provided by the U.S. Food and Drug Administration. Data is sourced from the FDA Adverse Event Reporting System (FAERS) and is freely available as open government data. This tool is intended for research and informational purposes only and does not constitute medical advice. Adverse event reports in FAERS represent unverified, voluntary submissions and do not establish a causal link between a drug and a reported event. Always consult a qualified healthcare professional for medical decisions. The Actor developer is not affiliated with the FDA or any pharmaceutical company.

# Actor input Schema

## `drugName` (type: `string`):

Filter by drug name (e.g. 'ASPIRIN', 'IBUPROFEN', 'ATORVASTATIN'). Case-insensitive. Leave blank to get all recent reports.

## `reaction` (type: `string`):

Filter by adverse reaction MedDRA term (e.g. 'NAUSEA', 'DEATH', 'CARDIAC ARREST'). Leave blank to include all reactions.

## `seriousOnly` (type: `boolean`):

If true, only return reports flagged as serious (hospitalization, death, life-threatening, etc.).

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

Filter reports received on or after this date. Format: YYYY-MM-DD (e.g. 2023-01-01).

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

Filter reports received on or before this date. Format: YYYY-MM-DD (e.g. 2023-12-31).

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

Maximum number of adverse event reports to return. OpenFDA caps pagination at 25,000 records per query.

## Actor input object example

```json
{
  "drugName": "ASPIRIN",
  "reaction": "NAUSEA",
  "seriousOnly": false,
  "dateFrom": "2023-01-01",
  "dateTo": "2023-12-31",
  "maxResults": 1000
}
```

# 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 = {
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/fda-adverse-events-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 = { "maxResults": 1000 }

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/fda-adverse-events-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 '{
  "maxResults": 1000
}' |
apify call compute-edge/fda-adverse-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=compute-edge/fda-adverse-events-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Adverse Events (FAERS) Scraper — Drug Safety Reports",
        "description": "Extract drug adverse event reports from the FDA FAERS database via openFDA API. Filter by drug name, reaction, severity, and date. Zero auth required.",
        "version": "0.1",
        "x-build-id": "MEw8ODDpEAPzMSAGe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~fda-adverse-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-fda-adverse-events-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/compute-edge~fda-adverse-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-fda-adverse-events-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/compute-edge~fda-adverse-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-fda-adverse-events-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": {
                    "drugName": {
                        "title": "Drug Name",
                        "type": "string",
                        "description": "Filter by drug name (e.g. 'ASPIRIN', 'IBUPROFEN', 'ATORVASTATIN'). Case-insensitive. Leave blank to get all recent reports."
                    },
                    "reaction": {
                        "title": "Adverse Reaction (MedDRA Term)",
                        "type": "string",
                        "description": "Filter by adverse reaction MedDRA term (e.g. 'NAUSEA', 'DEATH', 'CARDIAC ARREST'). Leave blank to include all reactions."
                    },
                    "seriousOnly": {
                        "title": "Serious Reports Only",
                        "type": "boolean",
                        "description": "If true, only return reports flagged as serious (hospitalization, death, life-threatening, etc.).",
                        "default": false
                    },
                    "dateFrom": {
                        "title": "Date From (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Filter reports received on or after this date. Format: YYYY-MM-DD (e.g. 2023-01-01)."
                    },
                    "dateTo": {
                        "title": "Date To (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Filter reports received on or before this date. Format: YYYY-MM-DD (e.g. 2023-12-31)."
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 25000,
                        "type": "integer",
                        "description": "Maximum number of adverse event reports to return. OpenFDA caps pagination at 25,000 records per query.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
