# Pharma Company Data — FDA Drug Approvals by Sponsor (Drugs@FDA) (`foxlabs/fda-drug-sponsor-data`) Actor

Look up pharmaceutical companies in Drugs@FDA by sponsor name. Returns every NDA/ANDA/BLA application, brand and generic names, active ingredients, dosage forms, marketing status, approval dates and route of administration.

- **URL**: https://apify.com/foxlabs/fda-drug-sponsor-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 company records

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Pharma Company Data — FDA Drug Approvals by Sponsor (Drugs@FDA) 💊

**foXLabs US registry-data series:** [US Healthcare Organizations (NPI)](https://apify.com/foxlabs/npi-healthcare-organization-data) · [Device Manufacturers (FDA)](https://apify.com/foxlabs/fda-device-manufacturer-data)

🎉 Turn Drugs@FDA into a clean, structured map of every drug a company has brought to the US market — no login, no API key, one row per approved application.
Built for pharma business-development & competitive intelligence, regulatory-affairs, market-access and healthcare investors.

### 🔍 What is the Pharma Company Data — and when should you use it?

Give this actor a sponsor name (`Pfizer`), a brand name (`Ozempic`) or an FDA application number (`NDA021436`) and it returns the matching approved applications — the sponsor, application type, brand names, active ingredients, dosage forms, marketing status, approval and latest-submission dates, and submission/product counts — as clean rows.

**Use it when you need:** a competitor’s full approved-drug portfolio; who sponsors a given brand and its application history; or resolving an NDA/ANDA/BLA number to its sponsor and products.

**Use something else when:** you need the sponsor’s corporate firmographics (address, headcount, revenue) — Drugs@FDA identifies a sponsor by name only; pair with a firmographic actor from [Fox Labs](https://apify.com/foxlabs). For device makers, use the [FDA device actor](https://apify.com/foxlabs/fda-device-manufacturer-data).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/fda-drug-sponsor-data`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered record, never for errors.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want to pull data using the Apify Actor `foxlabs/fda-drug-sponsor-data`.

Input: `queries` is a list of sponsor names, brand names or FDA application numbers (NDA/ANDA/BLA). `maxResultsPerQuery` caps rows per query (default 50).

Start with:
{ "queries": ["Pfizer"], "maxResultsPerQuery": 25 }

Ask me what to look up, run the Actor, then summarise the rows as a table.
```

Things you can ask your agent for:

- "List every approved drug Novo Nordisk sponsors, with approval dates."
- "Who sponsors Ozempic and what’s the application history?"
- "Resolve NDA021436 to its sponsor and products."

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/fda-drug-sponsor-data.md`.

### 📋 Overview

Everything you need to turn Drugs@FDA — the FDA’s official openFDA drug-approvals API, keyless into clean, structured data — in one actor, with no login, cookies or API key.

**Why teams pick this actor:**

- ✅ **Whole portfolio, one call** — sponsor, brand or application number in; every matching approved application out.
- 🔬 **Rich drug detail** — brands, active ingredients, dosage forms, marketing status, approval + latest-submission dates.
- 🔎 **Three search modes** — sponsor name, brand name, or NDA/ANDA/BLA number.
- 🧹 **Honest schema** — the value is the drug portfolio; columns a name-only registry can’t fill are not shipped empty.
- 💰 **Pay only for results** — per-row pricing, empty/failed lookups never billed.
- 🤖 **Agent-ready** — MCP + x402 agentic payments.

### ✨ Features

- 🔍 **Sponsor / brand / application search** — one input, three ways in.
- 💊 **Drug portfolio** — brand names, active ingredients, dosage forms per application.
- 📅 **Approval timeline** — approval date, latest submission date, submission + product counts.
- 🏷️ **Marketing status** — prescription, OTC, discontinued.
- 📦 **Clean export** — deduplicated camelCase rows, ready for CSV/Excel/JSON.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~fda-drug-sponsor-data/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "queries": ["Pfizer"], "maxResultsPerQuery": 25 }'
```

### 🚀 Getting Started (3 steps)

1. **Choose your targets** — sponsor names (`Pfizer`), brands (`Ozempic`) or application numbers (`NDA021436`).
2. **Set the cap** — `maxResultsPerQuery` limits rows per query (default 50).
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

```json
{
  "queries": ["Novo Nordisk", "Ozempic", "NDA021436"],
  "maxResultsPerQuery": 50
}
```

| Field | Type | Description |
|---|---|---|
| `queries` | array | Sponsor names, brand names or FDA application numbers (NDA/ANDA/BLA). |
| `maxResultsPerQuery` | integer | Caps rows per query (default 50). |
| `maxConcurrency` | integer | How many queries to fetch at once (default 4). |
| `includeRaw` | boolean | Attach the source’s untouched record under `raw`. |

### 📤 Output

One row per record, saved to the dataset. Every row also carries `query`, `scrapedAt`, and — when a lookup fails — an `error` explaining why (never silently dropped, never billed).

| Field | Type | Description |
|---|---|---|
| `companyName` | string | Sponsor as recorded by the FDA |
| `registrationNumber` | string | FDA application number (NDA/ANDA/BLA) — the join key |
| `applicationType` | string | NDA, ANDA or BLA |
| `brandNames` | array | Marketed brand name(s) |
| `activeIngredients` | array | Active ingredient(s) + strength |
| `dosageForms` | array | Dosage form(s) |
| `marketingStatus` | string | Prescription / OTC / discontinued |
| `approvedOn` | string | First approval date (ISO) |
| `latestSubmissionOn` | string | Most recent submission date (ISO) |
| `submissionCount` / `productCount` | integer | History depth |
| `genericName` / `routes` / `unii` | array | openFDA harmonized detail, where the application has marketed products |
| `sourceUrl` | string | Public accessdata.fda.gov URL |

```json
{
  "companyName": "PFIZER",
  "registrationNumber": "NDA018069",
  "applicationType": "NDA",
  "brandNames": ["…"],
  "activeIngredients": ["…"],
  "marketingStatus": "Prescription",
  "approvedOn": "…",
  "sourceUrl": "https://www.accessdata.fda.gov/…"
}
```

### 💼 Use cases

**1. Competitive portfolio mapping** — see a rival’s entire approved-drug footprint and timeline.
*Input:* sponsor names in `queries`. *Output:* applications + approval dates + status. *Use:* rank competitors by portfolio depth and recency.

**2. Brand → sponsor intelligence** — find who owns a brand and its application history.
*Input:* brand names in `queries`. *Output:* sponsor + application records. *Use:* attribute a market brand to its company.

**3. Diligence / market access** — verify an application’s status and history.
*Input:* NDA/ANDA/BLA numbers. *Output:* exact application records. *Use:* confirm approval + marketing status.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/fda-drug-sponsor-data').call({ "queries": ["Pfizer"], "maxResultsPerQuery": 25 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/fda-drug-sponsor-data').call(run_input={ "queries": ["Pfizer"], "maxResultsPerQuery": 25 })
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the actor API with your `queries` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay-per-event: **$0.002 per delivered record**. Empty or failed lookups are never billed. Bulk queries scale linearly; you pay for the rows you actually get. [View current pricing.](https://apify.com/foxlabs/fda-drug-sponsor-data)

### ❓ FAQ

**Do I need an FDA account, login or API key?** No. This reads the public openFDA Drugs@FDA API.

**What do I search by?** A sponsor name, a brand name, or an FDA application number (NDA/ANDA/BLA).

**Why are some rows missing generic name or route?** Those come from openFDA’s harmonized block, which exists only for applications with marketed products (~28%). Core sponsor, brand, ingredient and approval data are always present.

**Why is there no sponsor address?** Drugs@FDA identifies a sponsor by name only — it carries no firmographics. We don’t ship empty address columns.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting

- **Fewer rows than expected** — a sponsor may hold that many approved applications; raise `maxResultsPerQuery`.
- **A brand returns the parent sponsor’s name** — Drugs@FDA records the legal sponsor; the brand is in `brandNames`.
- **No rows for a number** — confirm the application-number format (e.g. `NDA021436`, `ANDA…`, `BLA…`).

### ⚠️ Trademark

Independent tool built on the public openFDA Drugs@FDA dataset. Not affiliated with or endorsed by the FDA or any named pharmaceutical company. Company and brand names belong to their owners and are used for identification only.

### ⚖️ Is it legal to scrape this data?

This actor reads public drug-approval records (business, not patient, data) from an official US government API published for public use. Results can still contain personal data (e.g. an official’s name); personal data is protected by the GDPR and similar laws, so only process it with a legitimate basis. See Apify’s blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor’s **Issues** tab
- 🧠 **More clean B2B data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.2 — 2026-09-06

- **Dropped empty-promise columns.** Removed the firmographic template fields Drugs@FDA does not carry for a sponsor (`taxNumber, legalForm, incorporatedOn, dissolvedOn, address, city, postalCode, countryName, industry, industryCode, employees, capital, website, email, phone, officers`). The product is the sponsor's *drug portfolio* — applications, brands, ingredients, approval dates, marketing status — which stay at 100%.
- **Output schema linked** in `actor.json` so the Store renders the Output tab.

#### 0.1

- Initial release: sponsor → drug portfolio from Drugs@FDA by sponsor name, brand name or FDA application number (NDA/ANDA/BLA). Returns brand names, active ingredients, dosage forms, marketing status, approval and latest-submission dates, and submission/product counts.

# Actor input Schema

## `queries` (type: `array`):

Sponsor names (`Pfizer`), brand names (`Ozempic`) or application numbers (`NDA021436`). Application numbers are exact lookups.

## `maxResultsPerQuery` (type: `integer`):

How many rows a single query may produce.

## `maxConcurrency` (type: `integer`):

How many queries to run at the same time. Lower it if the source throttles you.

## `includeRaw` (type: `boolean`):

Attach the source's untouched response under `raw`. Useful when you need a field this actor does not map.

## `requestDelayMs` (type: `integer`):

Politeness delay against a public source. Raise it for large runs.

## `proxyConfiguration` (type: `object`):

Optional. openFDA is an open API and rarely needs a proxy.

## Actor input object example

```json
{
  "queries": [
    "Novo Nordisk",
    "Pfizer",
    "Ozempic",
    "NDA021436"
  ],
  "maxResultsPerQuery": 10,
  "maxConcurrency": 4,
  "includeRaw": false,
  "requestDelayMs": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "queries": [
        "Novo Nordisk",
        "Pfizer",
        "Ozempic",
        "NDA021436"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/fda-drug-sponsor-data").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 = { "queries": [
        "Novo Nordisk",
        "Pfizer",
        "Ozempic",
        "NDA021436",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/fda-drug-sponsor-data").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 '{
  "queries": [
    "Novo Nordisk",
    "Pfizer",
    "Ozempic",
    "NDA021436"
  ]
}' |
apify call foxlabs/fda-drug-sponsor-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/fda-drug-sponsor-data"
        }
    }
}

```

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/fRmzj6upllcam2tyP/builds/3vdvWjzUDbsgYw0Q8/openapi.json