# FDA Adverse Event Scraper - FAERS Reports (`antishock/fda-adverse-events-faers-scraper`) Actor

Extract drug adverse event reports from the FDA FAERS database via openFDA. Filter by drug, ingredient, manufacturer, MedDRA reaction, country, seriousness and date. Returns reactions, suspect drugs, patient demographics and outcome flags for pharmacovigilance research.

- **URL**: https://apify.com/antishock/fda-adverse-events-faers-scraper.md
- **Developed by:** [Ryan Zinburg](https://apify.com/antishock) (community)
- **Categories:** Other, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 result exporteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## FDA Adverse Event Scraper - FAERS Drug Safety Reports

Extract **drug adverse event reports** from FAERS, the FDA Adverse Event Reporting System, through the openFDA API. More than 20 million reports of suspected side effects, with the drugs involved, the reactions reported, patient demographics and the seriousness outcome.

Public government source, no API key required, no proxy needed.

### What you get per report

| Field | Example |
|---|---|
| `safetyReportId` | 10003183 |
| `receivedDate`, `receiptDate` | 2026-02-28 |
| `serious` | true / false |
| `outcomeDeath`, `outcomeHospitalization`, `outcomeLifeThreatening`, `outcomeDisabling`, `outcomeCongenitalAnomaly`, `outcomeOther` | seriousness flags |
| `reactions`, `reactionCount` | \["Dyspepsia", "Nausea"] as MedDRA preferred terms |
| `suspectDrugs` | drugs coded as suspected cause |
| `allDrugs`, `drugRoles` | full drug list with suspect / concomitant / interacting |
| `indications` | what the drugs were taken for |
| `genericNames`, `brandNames`, `manufacturers` | normalised openFDA drug identity |
| `patientSex`, `patientAge`, `patientAgeUnit` | demographics where reported |
| `reporterQualification` | Physician, Pharmacist, Consumer, ... |
| `reporterCountry`, `occurCountry` | where it was reported and occurred |

### Search filters

- **drugName** - the reported product name, e.g. `IBUPROFEN`, `OZEMPIC`
- **activeIngredient** - generic name, e.g. `semaglutide`
- **manufacturer** - e.g. `Novo Nordisk`
- **reaction** - MedDRA term, e.g. `Nausea`, `Hepatic failure`
- **country** - reporter country code, e.g. `US`, `DE`
- **seriousOnly** - restrict to reports flagged as serious
- **outcome** - death, hospitalization, life threatening or disability
- **receivedAfter** / **receivedBefore** - date range, `YYYY-MM-DD`
- **maxResults** - up to 5000 reports per run

### Example input

```json
{
  "activeIngredient": "semaglutide",
  "seriousOnly": true,
  "receivedAfter": "2026-01-01",
  "maxResults": 500
}
```

### Use cases

- **Pharmacovigilance and signal detection** - count reactions per drug and watch how they trend
- **Medical affairs** - answer questions about the reported safety profile of a product
- **Competitive safety benchmarking** - compare reaction profiles across drugs in a class
- **Litigation and legal research** - assemble reported cases involving a product and an outcome
- **Health journalism and research** - quantify reports behind a safety story
- **Regulatory affairs** - prepare periodic safety reporting with source data

### Why FAERS

FAERS is the FDA's own collection of adverse event reports submitted by manufacturers, health professionals and consumers. It is the reference dataset behind most public drug safety analysis, updated quarterly and free to reuse.

### Important interpretation note

FAERS is a **spontaneous reporting** system. A report does not establish that the drug caused the event, reporting rates vary widely between products and countries, and the same case may be submitted more than once by different senders. Use the data for signal generation and comparison, not as evidence of causation or as an incidence rate.

### Notes

- Reports are deduplicated by safety report id within a run.
- openFDA refuses offsets beyond 25 000 records; narrow the filters to reach deeper into a large result set.
- Numeric FAERS codes for reporter role, drug role and sex are decoded into readable labels.

# Actor input Schema

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

Reported product name, e.g. IBUPROFEN, OZEMPIC.

## `activeIngredient` (type: `string`):

Generic name, e.g. semaglutide, metformin.

## `manufacturer` (type: `string`):

Manufacturer name as recorded by openFDA.

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

MedDRA preferred term, e.g. Nausea, Hepatic failure.

## `country` (type: `string`):

Two-letter country code of the reporter, e.g. US, DE.

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

Restrict to reports the FDA flags as serious.

## `outcome` (type: `string`):

Restrict to a specific seriousness outcome.

## `receivedAfter` (type: `string`):

Only reports received on or after this date (YYYY-MM-DD).

## `receivedBefore` (type: `string`):

Only reports received on or before this date (YYYY-MM-DD).

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

How many reports to save.

## Actor input object example

```json
{
  "drugName": "IBUPROFEN",
  "seriousOnly": false,
  "outcome": "ANY",
  "maxResults": 100
}
```

# Actor output Schema

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

Scraped records in the default dataset.

# 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 = {
    "drugName": "IBUPROFEN",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("antishock/fda-adverse-events-faers-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 = {
    "drugName": "IBUPROFEN",
    "maxResults": 100,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,antishock/fda-adverse-events-faers-scraper"
        }
    }
}
```

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/gks4kWpt92ECGLRNL/builds/1WJbYbBkfLVOZhR5t/openapi.json