# RxNorm Drug Concepts Scraper (NLM) (`parseforge/rxnorm-drug-concepts-scraper`) Actor

Pull standardized US drug concepts from the NLM RxNorm API — search by name, fetch all relations for an RxCUI, or browse every concept of a term type (SBD, SCD, IN, BN, SY). Returns RxCUI, name, term type, synonyms, base ingredients, and dose form group.

- **URL**: https://apify.com/parseforge/rxnorm-drug-concepts-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $27.37 / 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.
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/raw/main/banner.jpg)

## 💊 RxNorm Drug Concepts Scraper (NLM)

> 🚀 **Export standardized US drug concepts in seconds.** Search the **NIH/NLM RxNorm API** by drug name, fetch every related concept for a given RxCUI, or browse every concept of a term type (SBD, SCD, IN, BN, and more). No API key, no normalization headaches, no manual JSON parsing.

> 🕒 **Last updated:** 2026-05-13 · **📊 9 fields** per record · **💊 RxNorm vocabulary** · **🇺🇸 NIH-maintained**

The **RxNorm Drug Concepts Scraper** queries the official `rxnav.nlm.nih.gov` RxNorm API and returns standardized US drug concepts from the National Library of Medicine. Three lookup modes cover the common workflows: search by ingredient or brand name, pull every related concept for a known RxCUI, or browse every concept of a chosen term type (TTY). Each record carries the RxCUI, full RxNorm name, term type, synonym, language, suppression flag, the canonical RxNav URL, and the parsed base ingredient list.

RxNorm is the NIH-maintained standardized nomenclature for prescription and over-the-counter US drugs and is the lingua franca for clinical decision support, e-prescribing, and pharmacy claims. Coverage spans every TTY in the RxNorm release: **IN** (ingredient), **PIN**, **MIN**, **BN** (brand name), **SCD/SBD** (semantic clinical/branded drug), **SCDF/SBDF**, **SCDC/SBDC**, **DF**, **DFG**, **GPCK/BPCK**, **SY**, and **TMSY**.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Health-tech teams, pharmacy systems, clinical decision support vendors, EHR integrators, public-health researchers, formulary managers | Drug autocomplete, RxCUI mapping, brand-to-generic crosswalks, prescription normalization, formulary builds, clinical-trial dataset prep |

---

### 📋 What the RxNorm Scraper does

Three lookup modes in one Actor:

- 🔍 **Search mode.** Find every RxNorm concept that shares an ingredient or brand name (e.g. `aspirin`, `metformin`, `Lipitor`).
- 🆔 **byRxcui mode.** Pull every related concept (brand, generic, dose forms, components) for a given RxCUI.
- 📚 **allByType mode.** Browse the full catalog of a single term type, like every Semantic Branded Drug (`SBD`) or every Ingredient (`IN`).

Each record carries the RxCUI, full RxNorm name, term type, synonym, language, suppression flag, the canonical RxNav page URL, the run timestamp, and a parsed `baseNames` array that extracts the underlying ingredients embedded in compound concept names.

> 💡 **Why it matters:** drug data lives in fragmented forms across labels, NDC codes, and EHR vocabularies. RxNorm is the bridge. This Actor lets product, pharmacy, and research teams pull RxNorm into a spreadsheet without writing an API client.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing search mode, RxCUI pivot, and TTY browse._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>mode</code></td><td>enum</td><td><code>"search"</code></td><td>One of <code>search</code>, <code>byRxcui</code>, <code>allByType</code>.</td></tr>
<tr><td><code>name</code></td><td>string</td><td><code>"aspirin"</code></td><td>Drug or ingredient name. Used in <code>search</code> mode.</td></tr>
<tr><td><code>rxcui</code></td><td>string</td><td><code>""</code></td><td>RxNorm Concept Unique Identifier. Used in <code>byRxcui</code> mode.</td></tr>
<tr><td><code>tty</code></td><td>enum</td><td><code>"SBD"</code></td><td>One of 16 RxNorm term types. Used in <code>allByType</code> mode.</td></tr>
<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>
</tbody>
</table>

**Example: every concept related to RxCUI 161 (acetaminophen).**

```json
{
    "mode": "byRxcui",
    "rxcui": "161",
    "maxItems": 500
}
````

**Example: every Semantic Branded Drug (SBD) in RxNorm.**

```json
{
    "mode": "allByType",
    "tty": "SBD",
    "maxItems": 5000
}
```

> ⚠️ **Good to Know:** RxNorm releases monthly. Each run hits the live RxNav API so your output reflects the latest release. Term types like `SCD` and `SBD` are very large; browse with `maxItems` to keep runs scoped.

***

### 📊 Output

Each concept carries **9 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `rxcui` | string | `"2047428"` |
| 💊 `name` | string | `"Excedrin PM Triple Action Caplets and Excedrin Extra Strength Pain Reliever"` |
| 🏷️ `tty` | string | `"BPCK"` |
| 📝 `synonym` | string | `"Excedrin PM Triple Action Caplets and Excedrin Extra Strength Pain Reliever Kit"` |
| 🌐 `language` | string | `"ENG"` |
| 🚫 `suppress` | string | `"N"` |
| 🔗 `url` | string | `"https://mor.nlm.nih.gov/RxNav/search?searchBy=RXCUI&searchTerm=2047428"` |
| 🧪 `baseNames` | string\[] | `["aspirin","acetaminophen","caffeine","diphenhydramine"]` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T22:25:16.498Z"` |

#### 📦 Sample records

<details>
<summary><strong>🎒 Branded pack with multiple ingredients (TTY: BPCK)</strong></summary>

```json
{
    "rxcui": "2047428",
    "name": "{100 (acetaminophen 250 MG / aspirin 250 MG / caffeine 65 MG Oral Tablet [Excedrin]) / 24 (acetaminophen 250 MG / aspirin 250 MG / diphenhydramine citrate 38 MG Oral Tablet [Excedrin PM Triple Action]) } Pack [Excedrin PM Triple Action Caplets and Excedrin Extra Strength Pain Reliever]",
    "tty": "BPCK",
    "synonym": "Excedrin PM Triple Action Caplets and Excedrin Extra Strength Pain Reliever Kit",
    "language": "ENG",
    "suppress": "N",
    "url": "https://mor.nlm.nih.gov/RxNav/search?searchBy=RXCUI&searchTerm=2047428",
    "scrapedAt": "2026-05-13T22:25:16.498Z",
    "baseNames": [
        "aspirin",
        "acetaminophen",
        "caffeine",
        "diphenhydramine",
        "acetaminophen / aspirin / diphenhydramine",
        "acetaminophen / aspirin / caffeine",
        "diphenhydramine citrate"
    ]
}
```

</details>

<details>
<summary><strong>💊 Simple ingredient lookup (TTY: IN)</strong></summary>

```json
{
    "rxcui": "1191",
    "name": "aspirin",
    "tty": "IN",
    "synonym": "ASA",
    "language": "ENG",
    "suppress": "N",
    "url": "https://mor.nlm.nih.gov/RxNav/search?searchBy=RXCUI&searchTerm=1191",
    "baseNames": ["aspirin"],
    "scrapedAt": "2026-05-13T22:25:16.498Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 💊 | **Authoritative NIH source.** Pulls directly from the NLM RxNav API. |
| 🔁 | **Three modes.** Search, RxCUI lookup, or full TTY browse. One Actor covers them all. |
| 🧪 | **Parsed base ingredients.** A `baseNames` array surfaces underlying ingredients from compound names. |
| 🔗 | **Canonical RxNav URLs.** Every row links back to the official NLM concept page. |
| 🚫 | **No API key.** RxNav is a free public service. No registration needed. |
| ⚡ | **Fast.** 100 concepts in under 5 seconds. |
| 🔁 | **Always fresh.** Reflects the current monthly RxNorm release. |

> 📊 RxNorm is the standardized US drug vocabulary required by Meaningful Use, used in every certified EHR, and integrated into pharmacy and claims systems across the country.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Format | Setup |
|---|---|---|---|---|---|
| **⭐ RxNorm Scraper** *(this Actor)* | $5 free credit, then pay-per-use | Full RxNorm vocabulary | **Live per run** | Flat JSON / CSV | ⚡ 2 min |
| Direct RxNav REST calls | Free | Same | Live | Nested JSON | 🐢 Per-endpoint parsers |
| Monthly UMLS dump | Free | Same | Monthly | RRF files | ⏳ Hours |
| Commercial drug API | $$$ | Curated subsets | Real-time | JSON | ⏳ Vendor onboarding |

Pick this Actor when you want RxNorm in a flat table without writing a client or downloading the UMLS release.

***

### 🚀 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 RxNorm Drug Concepts Scraper page on the Apify Store.
3. 🎯 **Pick a mode.** Search by name, look up by RxCUI, or browse by TTY.
4. 🚀 **Run it.** Click **Start** and let the Actor walk the RxNav API.
5. 📥 **Download.** Grab results in the **Dataset** tab as CSV, Excel, JSON, or XML.

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

***

### 💼 Business use cases

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

#### 💊 Health Tech & EHR

- Drug-name autocomplete with canonical RxCUIs
- Brand-to-generic crosswalks for switching workflows
- e-Prescribing dropdowns powered by RxNorm
- Formulary builds backed by NLM data

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

#### 🏥 Pharmacy & Claims

- Normalize NDC, GPI, and proprietary codes to RxCUI
- Cross-vendor formulary reconciliation
- Drug pricing keys joined on RxCUI
- Pharmacy chain inventory normalization

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

#### 🔬 Clinical Research & Trials

- Cohort definitions by ingredient or brand
- ATC/RxNorm mapping for international studies
- Real-world evidence pipelines with stable IDs
- Public-health dashboards on prescription trends

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

#### 🤖 LLM & AI Health Tooling

- Ground LLM drug responses in NLM data
- Build RAG indexes over RxNorm concepts
- Training data for drug-NER classifiers
- Validation layers for AI clinical scribes

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

***

### 🔌 Automating RxNorm 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. Monthly refreshes track new RxNorm releases automatically.

***

### 🌟 Beyond business use cases

RxNorm data feeds far more than commercial health-tech. The same structured records support research, education, and public-health work.

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

#### 🎓 Research and academia

- Pharmacoepidemiology papers using stable RxCUIs
- Clinical-trial datasets prepared for reproducibility
- Coursework on standardized terminologies
- Dissertations on drug naming and synonyms

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

#### 🎨 Personal and creative

- Hobbyist medication-tracking apps
- Patient-side drug references and tools
- Education tools and quizzes on drug names
- Indie projects in health literacy

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

#### 🤝 Non-profit and civic

- Patient-advocacy resources on brand-to-generic options
- Free clinic formulary management
- Civic transparency on public drug formularies
- Plain-language drug glossaries for patients

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

#### 🧪 Experimentation

- Train drug-NER models on RxNorm labels
- Prototype agents that resolve drug names to RxCUIs
- Test e-prescribing UI flows with real data
- Benchmark drug-normalization tooling

</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%20RxNorm%20Drug%20Concepts%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%20clinical%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20RxNorm%20Drug%20Concepts%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%20clinical%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20RxNorm%20Drug%20Concepts%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%20clinical%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20RxNorm%20Drug%20Concepts%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%20clinical%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a mode, set the relevant input (name, RxCUI, or TTY), and click Start. The Actor calls the RxNav REST API, normalizes the nested response into a flat record per concept, and emits the result with a parsed `baseNames` ingredient array.

#### 🆔 What is an RxCUI?

An RxCUI is an RxNorm Concept Unique Identifier. It is the stable numeric ID that NLM assigns to every drug concept (ingredient, brand, dose form, branded pack, etc.). Use it as a join key across health systems.

#### 🏷️ What is a TTY?

Term Type. RxNorm partitions concepts into types like `IN` (Ingredient), `BN` (Brand Name), `SCD` (Semantic Clinical Drug), `SBD` (Semantic Branded Drug), and so on. The Actor accepts every TTY in the RxNorm release.

#### 🔁 How fresh is the data?

RxNorm has a monthly release cycle. Every run hits the live RxNav API, so the output reflects the current release.

#### 🌍 Does this include non-US drugs?

RxNorm is a US drug terminology. International coverage exists for some drugs through RxNorm International extensions, but the canonical RxNorm vocabulary is US-focused.

#### 🚫 Do I need an API key?

No. RxNav is a free NIH service that does not require authentication.

#### ⏰ Can I schedule monthly refreshes?

Yes. Use Apify Schedules to run the Actor on the first of every month and pipe results into your warehouse.

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

Yes. NLM publishes RxNorm in the public domain in the United States. Review your downstream regulatory needs (HIPAA, etc.) for clinical use.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers small runs (10 records). A paid plan unlocks higher limits and scheduling.

#### 🆘 What if I need help?

Reach out via the contact form below to request a custom drug workflow or a feature.

***

### 🔌 Integrate with any app

RxNorm Drug Concepts Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step clinical workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get release notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe RxNorm 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 RxNorm data into your EHR or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**🏥 ICD-10-CM, LOINC & Clinical Terminology Scraper**](https://apify.com/parseforge/icd10-loinc-clinical-scraper) - Pair RxNorm with diagnosis and lab codes
- [**🧬 UniProt Protein Scraper**](https://apify.com/parseforge/uniprot-scraper) - Protein knowledgebase entries for biomedical work
- [**🤗 Hugging Face Model Scraper**](https://apify.com/parseforge/hugging-face-model-scraper) - AI model registry metadata
- [**🛡️ urlscan.io Threat Intelligence Scraper**](https://apify.com/parseforge/urlscan-scraper) - Live web scan data
- [**🌐 RDAP Domain Lookup Scraper**](https://apify.com/parseforge/rdap-domain-lookup-scraper) - Modern WHOIS replacement

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data 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. National Library of Medicine, the National Institutes of Health, or any government agency. All trademarks mentioned are the property of their respective owners. Only publicly available RxNorm data from the RxNav API is collected.

# Actor input Schema

## `mode` (type: `string`):

What to fetch:

- search — look up all RxNorm concepts that share an ingredient name
- byRxcui — fetch every related concept for a given RxCUI
- allByType — browse every concept of a given term type (TTY)

## `name` (type: `string`):

Ingredient or brand name to search (e.g. "aspirin", "metformin"). Only used when mode = search.

## `rxcui` (type: `string`):

An RxNorm Concept Unique Identifier (e.g. 161 = acetaminophen). Only used when mode = byRxcui.

## `tty` (type: `string`):

RxNorm Term Type to browse. Only used when mode = allByType.

- IN = Ingredient
- PIN = Precise Ingredient
- MIN = Multiple Ingredients
- BN = Brand Name
- SCD = Semantic Clinical Drug
- SBD = Semantic Branded Drug
- SCDC/SBDC = Drug Component
- SCDF/SBDF = Drug Form
- GPCK/BPCK = Pack
- DF = Dose Form
- SY = Synonym
- TMSY = Tall-Man Synonym

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

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

## Actor input object example

```json
{
  "mode": "search",
  "name": "aspirin",
  "tty": "SBD",
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

## `fullData` (type: `string`):

Complete 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 = {
    "mode": "search",
    "name": "aspirin",
    "tty": "SBD",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/rxnorm-drug-concepts-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 = {
    "mode": "search",
    "name": "aspirin",
    "tty": "SBD",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/rxnorm-drug-concepts-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 '{
  "mode": "search",
  "name": "aspirin",
  "tty": "SBD",
  "maxItems": 10
}' |
apify call parseforge/rxnorm-drug-concepts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RxNorm Drug Concepts Scraper (NLM)",
        "description": "Pull standardized US drug concepts from the NLM RxNorm API — search by name, fetch all relations for an RxCUI, or browse every concept of a term type (SBD, SCD, IN, BN, SY). Returns RxCUI, name, term type, synonyms, base ingredients, and dose form group.",
        "version": "0.0",
        "x-build-id": "fqGVCKRb1gzp454RL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~rxnorm-drug-concepts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-rxnorm-drug-concepts-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~rxnorm-drug-concepts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-rxnorm-drug-concepts-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~rxnorm-drug-concepts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-rxnorm-drug-concepts-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byRxcui",
                            "allByType"
                        ],
                        "type": "string",
                        "description": "What to fetch:\n  - search — look up all RxNorm concepts that share an ingredient name\n  - byRxcui — fetch every related concept for a given RxCUI\n  - allByType — browse every concept of a given term type (TTY)",
                        "default": "search"
                    },
                    "name": {
                        "title": "Drug Name (search mode)",
                        "type": "string",
                        "description": "Ingredient or brand name to search (e.g. \"aspirin\", \"metformin\"). Only used when mode = search."
                    },
                    "rxcui": {
                        "title": "RxCUI (byRxcui mode)",
                        "type": "string",
                        "description": "An RxNorm Concept Unique Identifier (e.g. 161 = acetaminophen). Only used when mode = byRxcui."
                    },
                    "tty": {
                        "title": "Term Type (allByType mode)",
                        "enum": [
                            "IN",
                            "PIN",
                            "MIN",
                            "BN",
                            "SCD",
                            "SBD",
                            "SCDC",
                            "SBDC",
                            "SCDF",
                            "SBDF",
                            "GPCK",
                            "BPCK",
                            "DF",
                            "DFG",
                            "SY",
                            "TMSY"
                        ],
                        "type": "string",
                        "description": "RxNorm Term Type to browse. Only used when mode = allByType.\n  - IN = Ingredient\n  - PIN = Precise Ingredient\n  - MIN = Multiple Ingredients\n  - BN = Brand Name\n  - SCD = Semantic Clinical Drug\n  - SBD = Semantic Branded Drug\n  - SCDC/SBDC = Drug Component\n  - SCDF/SBDF = Drug Form\n  - GPCK/BPCK = Pack\n  - DF = Dose Form\n  - SY = Synonym\n  - TMSY = Tall-Man Synonym"
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
