# ICD-10-CM, LOINC & Clinical Terminology Scraper (NLM) (`parseforge/icd10-loinc-clinical-scraper`) Actor

Query the NLM Clinical Tables API to export billable medical codes — ICD-10-CM diagnoses, LOINC lab observations, disease names, procedures, condition URIs, and drug classes. Free, no API key, exact NLM source data.

- **URL**: https://apify.com/parseforge/icd10-loinc-clinical-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.75 / 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)

## 🏥 ICD-10-CM, LOINC & Clinical Terminology Scraper (NLM)

> 🚀 **Export billable clinical codes in seconds.** Query the official **NLM Clinical Tables API** for ICD-10-CM diagnoses, LOINC lab observations, RxTerms drugs, disease names, conditions, and procedures. No API key, no UMLS download, no parser headaches.

> 🕒 **Last updated:** 2026-05-13 · **📊 6 clinical tables** · **🇺🇸 NIH-maintained** · **💯 100,000+ codes total**

The **ICD-10-CM, LOINC & Clinical Terminology Scraper** queries the National Library of Medicine's Clinical Tables Search Service and returns standardized US clinical codes as flat rows. Six tables are supported in one Actor: **ICD-10-CM** (billable US diagnosis codes), **LOINC** (laboratory and clinical observations), **RxTerms** (drug names with dose, strength, route), **disease_names** (curated disease dictionary), **conditions** (common patient-reported conditions), and **procedures** (common medical procedures with ICD-9 codes).

Each table returns its own purpose-built schema while sharing a common `table` and `scrapedAt` envelope, so consumers can union the output or filter to a single vocabulary. Coverage is **tens of thousands of rows per table**, totaling well over **100,000 standardized clinical codes** across the six tables. The Clinical Tables API is the same backend that powers the NLM autocomplete widgets used inside FHIR pickers and EHR build-out tools.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Health-tech teams, EHR integrators, billing & RCM vendors, clinical-decision-support builders, public-health researchers, FHIR app developers | Diagnosis-code autocomplete, lab-code lookup, RxTerms-to-RxNorm bridge, disease-name normalization, procedure code translation, FHIR ValueSet builds |

---

### 📋 What the Clinical Terminology Scraper does

Six lookup workflows in one Actor:

- 🏥 **ICD-10-CM.** Billable US diagnosis codes (`A00.0` → `Z99.x`).
- 🧪 **LOINC.** Laboratory and clinical observation codes with property, system, scale type, method, and class.
- 💊 **RxTerms.** Drug display name plus strength and form, joined to RxCUIs.
- 🩺 **disease_names.** Curated disease dictionary with consumer-friendly names and synonyms.
- 🤒 **conditions.** Common patient-reported conditions.
- 🩻 **procedures.** Common medical procedures keyed to ICD-9 procedure codes.

Each row carries the table name, the run timestamp, and the table-specific columns (e.g. `code` + `description` for ICD-10-CM, `code` + `longName` + `component` + `system` + `class` for LOINC, `name` + `strengthAndForm` + `rxcui` for RxTerms).

> 💡 **Why it matters:** clinical-code vocabularies live behind UMLS licensing, monthly release dumps, and ad-hoc autocomplete widgets. This Actor flattens all six into one API surface and one Apify dataset, ready for FHIR, billing, or analytics work.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing an ICD-10-CM diabetes pull, LOINC lab lookup, and RxTerms export._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>table</code></td><td>enum</td><td><code>"icd10cm"</code></td><td>One of <code>icd10cm</code>, <code>loinc_items</code>, <code>rxterms</code>, <code>disease_names</code>, <code>conditions</code>, <code>procedures</code>.</td></tr>
<tr><td><code>query</code></td><td>string</td><td><code>"diabetes"</code></td><td>Search terms matching code or display name. Empty = browse from the top.</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>
<tr><td><code>pageSize</code></td><td>integer</td><td><code>500</code></td><td>Rows per API request. NLM hard max is 500.</td></tr>
</tbody>
</table>

**Example: every ICD-10-CM code containing "diabetes".**

```json
{
    "table": "icd10cm",
    "query": "diabetes",
    "maxItems": 500
}
````

**Example: LOINC lab codes for hemoglobin observations.**

```json
{
    "table": "loinc_items",
    "query": "hemoglobin",
    "maxItems": 200
}
```

> ⚠️ **Good to Know:** the six tables return different field sets. Plan for table-aware columns when unioning datasets. The NLM API caps each page at 500 rows; the Actor pages transparently, so `maxItems` works up to the platform limit.

***

### 📊 Output

Schema is **table-dependent**. Every row carries `table` and `scrapedAt`, plus table-specific columns. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schemas

##### 🏥 `icd10cm`

| Field | Type | Example |
|---|---|---|
| 🏷️ `table` | string | `"icd10cm"` |
| 🔢 `code` | string | `"A00.0"` |
| 📝 `description` | string | `"Cholera due to Vibrio cholerae 01, biovar cholerae"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T22:25:16.845Z"` |

##### 🧪 `loinc_items`

| Field | Type | Example |
|---|---|---|
| 🏷️ `table` | string | `"loinc_items"` |
| 🔢 `code` | string | `"718-7"` |
| 📝 `longName` | string | `"Hemoglobin [Mass/volume] in Blood"` |
| 🧬 `component` | string | `"Hemoglobin"` |
| ⚖️ `property` | string | `"MCnc"` |
| ⏱️ `timeAspect` | string | `"Pt"` |
| 🩸 `system` | string | `"Bld"` |
| 📐 `scaleType` | string | `"Qn"` |
| 🛠️ `methodType` | string | `""` |
| 📚 `class` | string | `"HEM/BC"` |
| 🚦 `status` | string | `"ACTIVE"` |

##### 💊 `rxterms`

| Field | Type | Example |
|---|---|---|
| 🏷️ `table` | string | `"rxterms"` |
| 💊 `name` | string | `"aspirin"` |
| 🥄 `strengthAndForm` | string | `"81 MG Tab"` |
| 🆔 `rxcui` | string | `"243670"` |

##### 🩺 `disease_names` & 🤒 `conditions`

| Field | Type | Example |
|---|---|---|
| 🏷️ `table` | string | `"conditions"` |
| 🩺 `name` | string | `"Type 2 diabetes mellitus"` |
| 👥 `consumerName` | string | `"Type 2 diabetes"` |
| 🔁 `synonyms` | string | `"NIDDM; adult-onset diabetes"` |

##### 🩻 `procedures`

| Field | Type | Example |
|---|---|---|
| 🏷️ `table` | string | `"procedures"` |
| 🩻 `procedure` | string | `"Coronary artery bypass graft"` |
| 🔢 `icd9Code` | string | `"36.10"` |

#### 📦 Sample records

<details>
<summary><strong>🏥 ICD-10-CM diagnosis code</strong></summary>

```json
{
    "table": "icd10cm",
    "scrapedAt": "2026-05-13T22:25:16.845Z",
    "code": "A00.0",
    "description": "Cholera due to Vibrio cholerae 01, biovar cholerae"
}
```

</details>

<details>
<summary><strong>🧪 LOINC lab observation</strong></summary>

```json
{
    "table": "loinc_items",
    "code": "718-7",
    "longName": "Hemoglobin [Mass/volume] in Blood",
    "component": "Hemoglobin",
    "property": "MCnc",
    "timeAspect": "Pt",
    "system": "Bld",
    "scaleType": "Qn",
    "methodType": "",
    "class": "HEM/BC",
    "status": "ACTIVE",
    "scrapedAt": "2026-05-13T22:25:16.845Z"
}
```

</details>

<details>
<summary><strong>💊 RxTerms drug entry</strong></summary>

```json
{
    "table": "rxterms",
    "name": "aspirin",
    "strengthAndForm": "81 MG Tab",
    "rxcui": "243670",
    "scrapedAt": "2026-05-13T22:25:16.845Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏥 | **Six tables in one Actor.** ICD-10-CM, LOINC, RxTerms, disease names, conditions, procedures. |
| 🚫 | **No API key.** NLM Clinical Tables is a free public service. |
| 📑 | **Purpose-built schemas.** Each table returns the right columns instead of a one-size-fits-all blob. |
| ⚡ | **Fast pagination.** Pages up to 500 rows at a time, transparently. |
| 🔁 | **Always fresh.** Every run hits the live NLM endpoint. |
| 🇺🇸 | **NIH-maintained source.** The same data NLM publishes through its autocomplete widgets. |
| 🤝 | **Bridges to RxNorm.** RxTerms output carries the RxCUI so you can join straight into our RxNorm Scraper. |

> 📊 ICD-10-CM and LOINC are mandated for US healthcare billing, lab interoperability, and FHIR ValueSets. RxTerms is the consumer-facing drug terminology recommended for prescribing UIs.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Format | Setup |
|---|---|---|---|---|---|
| **⭐ Clinical Terminology Scraper** *(this Actor)* | $5 free credit, then pay-per-use | 6 NLM tables | **Live per run** | Flat JSON / CSV | ⚡ 2 min |
| UMLS RRF dump | Free, license required | UMLS sources | Quarterly | RRF files | 🐢 Hours |
| Direct CTSS REST calls | Free | Same | Live | Nested JSON | 🐢 Per-table parsers |
| Commercial terminology API | $$$ | Curated | Real-time | JSON | ⏳ Vendor onboarding |

Pick this Actor when you want NLM terminologies in flat tables without writing six different parsers.

***

### 🚀 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 ICD-10-CM, LOINC & Clinical Terminology Scraper page on the Apify Store.
3. 🎯 **Pick a table.** Choose one of the six tables and supply an optional search term.
4. 🚀 **Run it.** Click **Start** and let the Actor walk the NLM API.
5. 📥 **Download.** Grab results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to a billable code export: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

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

#### 🏥 EHR & Health Tech

- ICD-10-CM autocomplete for charting
- LOINC pickers for lab order entry
- RxTerms-powered prescribing dropdowns
- FHIR ValueSet builds from NLM source

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

#### 💰 Billing & RCM

- Verify diagnosis codes against the active US set
- Map procedure descriptions to ICD-9 codes
- Build payer-side claims edit lookups
- Normalize free-text claim narratives

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

#### 🔬 Clinical Research

- Cohort definitions by ICD-10-CM
- LOINC-coded lab data harmonization
- Disease-name normalization across registries
- Public-health dashboards on diagnosis trends

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

#### 🤖 LLM & Health AI

- Ground LLM responses in NLM-authoritative codes
- Build RAG indexes for clinical chatbots
- Training data for diagnosis-NER models
- Validation layers for AI clinical scribes

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

***

### 🔌 Automating Clinical Terminology 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. ICD-10-CM and RxTerms have annual or quarterly release cycles. Schedule a monthly refresh and you will always be current.

***

### 🌟 Beyond business use cases

Clinical terminology 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

- Reproducible cohort definitions with versioned ValueSets
- Coursework on standardized terminologies
- Epidemiology projects keyed to ICD-10-CM
- Health-services research with stable code IDs

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

#### 🎨 Personal and creative

- Patient-facing symptom lookup tools
- Indie health-literacy apps and glossaries
- Hobbyist medical-coding study aids
- Personal lab-result dashboards keyed to LOINC

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

#### 🤝 Non-profit and civic

- Free-clinic billing setup with current codes
- NGO public-health data harmonization
- Civic transparency on coded disease prevalence
- Plain-language patient education materials

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

#### 🧪 Experimentation

- Train clinical-NER models on NLM labels
- Prototype FHIR app pickers powered by live data
- Test EHR integrations with authoritative codes
- Benchmark code-resolution agents

</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%20ICD-10-CM%2C%20LOINC%20%26%20Clinical%20Terminology%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%20ICD-10-CM%2C%20LOINC%20%26%20Clinical%20Terminology%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%20ICD-10-CM%2C%20LOINC%20%26%20Clinical%20Terminology%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%20ICD-10-CM%2C%20LOINC%20%26%20Clinical%20Terminology%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 one of the six tables, supply an optional search term, and click Start. The Actor calls the NLM Clinical Tables Search Service, pages through results, and emits a flat row per code with the table-appropriate columns.

#### 📚 What are the six tables?

`icd10cm` (US billable diagnosis codes), `loinc_items` (lab and clinical observations), `rxterms` (drug display names and strengths), `disease_names` (curated disease dictionary), `conditions` (patient-reported conditions), and `procedures` (procedures keyed to ICD-9 codes).

#### 🆚 Why not just download UMLS?

UMLS requires a free license, ships as quarterly RRF dumps, and forces you to write per-source parsers. The Clinical Tables API is the same data delivered live over JSON. If you only need a slice, this Actor is the path of least resistance.

#### 🔁 How fresh is the data?

Every run hits the live NLM API, so output reflects the current released vocabulary.

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

No. NLM Clinical Tables is a free public service.

#### 📑 Can I get the codes that match ICD-10-PCS or HCPCS?

This Actor covers ICD-10-CM (diagnoses), not ICD-10-PCS (procedures). The `procedures` table is keyed to ICD-9 procedure codes. If you need ICD-10-PCS or HCPCS, contact us via the form below.

#### 🔁 Can I combine tables in one dataset?

Yes. Run the Actor multiple times into the same dataset (Apify supports appending). Every row carries a `table` field so you can split by vocabulary downstream.

#### ⏰ Can I schedule recurring runs?

Yes. Use Apify Schedules to refresh on the cadence that suits your release cycle.

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

Yes. NLM publishes these tables 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 terminology workflow.

***

### 🔌 Integrate with any app

Clinical Terminology 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 codes 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. Push fresh codes into your EHR or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**💊 RxNorm Drug Concepts Scraper**](https://apify.com/parseforge/rxnorm-drug-concepts-scraper) - Standardized US drug vocabulary
- [**🧬 UniProt Protein Scraper**](https://apify.com/parseforge/uniprot-scraper) - Protein knowledgebase entries
- [**🤗 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, the World Health Organization, the Regenstrief Institute, or any government agency. All trademarks mentioned are the property of their respective owners. Only publicly available NLM Clinical Tables data is collected.

# Actor input Schema

## `table` (type: `string`):

Which NLM Clinical Tables resource to query:

- icd10cm — ICD-10-CM diagnosis codes (billable US)
- loinc\_items — LOINC laboratory and clinical observations
- rxterms — RxTerms drug names with dose, strength, route
- disease\_names — disease name dictionary
- conditions — common patient-reported conditions
- procedures — common medical procedures

## `query` (type: `string`):

Search terms (matches code or display name). Leave empty to browse the whole table from the top.

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

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

## `pageSize` (type: `integer`):

Rows per API request (NLM hard max is 500).

## Actor input object example

```json
{
  "table": "icd10cm",
  "query": "diabetes",
  "maxItems": 10,
  "pageSize": 500
}
```

# 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 = {
    "table": "icd10cm",
    "query": "diabetes",
    "maxItems": 10,
    "pageSize": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/icd10-loinc-clinical-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 = {
    "table": "icd10cm",
    "query": "diabetes",
    "maxItems": 10,
    "pageSize": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/icd10-loinc-clinical-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 '{
  "table": "icd10cm",
  "query": "diabetes",
  "maxItems": 10,
  "pageSize": 500
}' |
apify call parseforge/icd10-loinc-clinical-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ICD-10-CM, LOINC & Clinical Terminology Scraper (NLM)",
        "description": "Query the NLM Clinical Tables API to export billable medical codes — ICD-10-CM diagnoses, LOINC lab observations, disease names, procedures, condition URIs, and drug classes. Free, no API key, exact NLM source data.",
        "version": "0.0",
        "x-build-id": "7CMpRhFKx2AwSdUFq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~icd10-loinc-clinical-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-icd10-loinc-clinical-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~icd10-loinc-clinical-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-icd10-loinc-clinical-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~icd10-loinc-clinical-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-icd10-loinc-clinical-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": [
                    "table"
                ],
                "properties": {
                    "table": {
                        "title": "Clinical Table",
                        "enum": [
                            "icd10cm",
                            "loinc_items",
                            "rxterms",
                            "disease_names",
                            "conditions",
                            "procedures"
                        ],
                        "type": "string",
                        "description": "Which NLM Clinical Tables resource to query:\n  - icd10cm — ICD-10-CM diagnosis codes (billable US)\n  - loinc_items — LOINC laboratory and clinical observations\n  - rxterms — RxTerms drug names with dose, strength, route\n  - disease_names — disease name dictionary\n  - conditions — common patient-reported conditions\n  - procedures — common medical procedures",
                        "default": "icd10cm"
                    },
                    "query": {
                        "title": "Search Terms",
                        "type": "string",
                        "description": "Search terms (matches code or display name). Leave empty to browse the whole table from the top."
                    },
                    "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"
                    },
                    "pageSize": {
                        "title": "Page Size",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Rows per API request (NLM hard max is 500).",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
