# 🏥 Healthcare & FDA Intelligence MCP (`nexgendata/healthcare-fda-intelligence-mcp`) Actor

Scrape the FAA Aircraft Registry by N-number — aircraft make, model, year, owner name, address, airworthiness category, engine type, registration status, certificate dates, mode-S code. Built for aviation insurers, jet brokers, journalists tracking ownership, NTSB-adjacent safety researchers.

- **URL**: https://apify.com/nexgendata/healthcare-fda-intelligence-mcp.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 aircraft records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 🏥 Healthcare & FDA Intelligence MCP

**One MCP connection. The FDA, NIH, CMS, CDC, and ClinicalTrials.gov — all agent-ready.**

Healthcare & FDA Intelligence MCP is a [Model Context Protocol](https://modelcontextprotocol.io) server that gives any AI agent — Claude, ChatGPT, Cursor, or a custom pipeline — direct, structured access to the core US healthcare and life-sciences data streams: drug labels and approvals, adverse events, recalls, warning letters, drug shortages, the Orange and Purple Books, 510(k) device clearances, pharma catalysts, clinical trials, NIH grants, CMS Open Payments, PubMed, and CDC surveillance.

Connect once and call fifteen clean tools. Each returns normalized JSON your agent can reason over immediately — no openFDA pagination, no ClinicalTrials.gov query syntax, no Sunshine Act CSV wrangling.

### Why this exists

Healthcare data is the richest free public dataset in existence and one of the most fragmented. openFDA, ClinicalTrials.gov, NIH RePORTER, CMS Open Payments, the FDA Orange/Purple Books, and CDC WONDER each have their own API, format, and rate limits — and none of them share a schema. Pulling them together for an agent means solving each one and re-solving as they change. This server does that work once and exposes the result as agent-native tools.

The same NexGenData infrastructure that powers our standalone FDA, pharma, and healthcare actors — used by pharma competitive-intelligence teams, biotech analysts, med-device firms, and life-sciences investors — now sits behind a single streamable-HTTP endpoint.

### The fifteen tools

| Tool | What it does |
|------|--------------|
| `search_drug_labels` | FDA drug labels, approvals, safety (openFDA) |
| `fda_drug_approvals` | New FDA drug approvals (NDA/BLA/ANDA) |
| `fda_adverse_events` | FAERS drug + MAUDE device adverse-event reports |
| `fda_recalls` | FDA drug & device recalls and safety alerts |
| `fda_warning_letters` | FDA warning letters + Form 483 inspection findings |
| `track_drug_shortages` | Current and resolved FDA drug shortages |
| `search_orange_book` | Drug patents & exclusivity (generic-entry timing) |
| `search_purple_book` | Biologics & biosimilars + reference-product linkage |
| `search_device_510k` | FDA 510(k) medical-device clearances |
| `track_pharma_catalysts` | Pipeline catalysts and PDUFA decision dates |
| `search_clinical_trials` | ClinicalTrials.gov by condition, sponsor, phase |
| `search_pubmed` | PubMed biomedical literature |
| `nih_grants` | NIH RePORTER funded research grants |
| `cms_open_payments` | CMS Open Payments (Sunshine Act) pharma-to-physician |
| `cdc_surveillance` | CDC WONDER + FluView public-health surveillance |

Every tool accepts a `criteria` object and a `limit`, and returns a uniform `{tool, count, total_available, results}` envelope — one parser for all fifteen.

### Quick start

```json
{
  "mcpServers": {
    "healthcare-fda": {
      "url": "https://nexgendata--healthcare-fda-intelligence-mcp.apify.actor/mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
````

Call a tool:

```jsonc
{
  "name": "search_orange_book",
  "arguments": { "criteria": { "ingredient": "apixaban" }, "limit": 25 }
}
```

### Common agent workflows

**Generic-entry / patent-cliff analysis.** Chain `search_orange_book` and `search_purple_book` to map when a drug's patents and exclusivity expire and which biosimilars reference it — the timing that drives generic competition.

**Drug-safety monitoring.** Run `fda_adverse_events`, `fda_recalls`, and `fda_warning_letters` on a product or manufacturer to build a live safety-signal feed.

**Pharma catalyst calendar.** Combine `track_pharma_catalysts`, `fda_drug_approvals`, and `search_clinical_trials` to track the events that move biotech valuations.

**Payer & provider intelligence.** Use `cms_open_payments` to surface pharma/device financial relationships with named physicians.

**Research landscaping.** Pair `search_pubmed` and `nih_grants` to map who is publishing and who is funded in a therapeutic area.

### Pricing

Pay-per-event: **$0.10 per tool call**, **$0.05 per bulk result** (>10 records), negligible session-start fee. No subscription, no seat license. An agent firing 200 healthcare queries a month costs about $20 — versus the five- and six-figure annual contracts of IQVIA, Definitive Healthcare, or Citeline.

### How this compares

**vs. IQVIA / Citeline / Definitive Healthcare:** built for enterprise seats and priced accordingly. This is built for agents, priced per call, and returns machine-ready JSON with source identifiers.

**vs. raw openFDA + ClinicalTrials.gov + NIH + CMS:** each is free but has a different API, format, and rate limit. This unifies fifteen of them behind one schema and one connection.

### Companion servers

- **SEC Corporate Events MCP** — market-moving filings for the pharma/biotech names you're tracking.
- **Legal & IP Intelligence MCP** — litigation, FDA-adjacent enforcement, and IP.
- **Environmental & ESG MCP** — EPA, public-health, and nonprofit data.

### FAQ

**Do I need an FDA or NIH API key?** No — only an Apify token for the MCP endpoint; upstream access is handled server-side.

**How fresh is the data?** Each tool queries its source live at call time.

**Can I filter by date, drug, or sponsor?** Yes — pass those in the `criteria` object; supported filters depend on the source.

**Is this medical advice?** No. This returns public regulatory and research data for informational use only — not medical advice.

**Is the schema stable?** Yes — every tool returns the same envelope; we version any changes.

*Healthcare & FDA Intelligence MCP — by NexGenData. The FDA, NIH, CMS, and CDC, agent-ready.*

# Actor input Schema

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/healthcare-fda-intelligence-mcp").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/healthcare-fda-intelligence-mcp").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 '{}' |
apify call nexgendata/healthcare-fda-intelligence-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/healthcare-fda-intelligence-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🏥 Healthcare & FDA Intelligence MCP",
        "description": "Scrape the FAA Aircraft Registry by N-number — aircraft make, model, year, owner name, address, airworthiness category, engine type, registration status, certificate dates, mode-S code. Built for aviation insurers, jet brokers, journalists tracking ownership, NTSB-adjacent safety researchers.",
        "version": "0.0",
        "x-build-id": "eyEFC0sYlJMqGeaRd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~healthcare-fda-intelligence-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-healthcare-fda-intelligence-mcp",
                "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/nexgendata~healthcare-fda-intelligence-mcp/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-healthcare-fda-intelligence-mcp",
                "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/nexgendata~healthcare-fda-intelligence-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-healthcare-fda-intelligence-mcp",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```