What You Can Build with a Free Healthcare Coding API

If you've ever tried to add medical coding data to an application, you know the pattern: download a 2 GB flat file from a government FTP server, write a parser for a format that hasn't changed since 1996, load it into a database, and then do it again next quarter when the codes change. Or pay five figures a year for an enterprise terminology service that requires a sales call to even see the pricing page.

There's a middle ground. FHIRfly is a clinical coding API built for developers who need accurate, up-to-date healthcare data without the procurement overhead. This post walks through what you can actually do with the free tier — and what changes when you move to the $19/month Developer plan.

What's in the Box

FHIRfly provides search and lookup endpoints for the code systems that healthcare applications actually use:

Code System	What It Covers	Source
NDC	Drug products and packages (300K+ codes)	FDA DRLS
ICD-10-CM/PCS	Diagnosis and procedure codes	CMS
LOINC	Lab tests and clinical observations	Regenstrief Institute
SNOMED CT	Clinical concepts (400K+ terms)	NLM/IHTSDO
HCPCS Level II	Medical procedures and supplies	CMS
CPT	Physician procedures (Category I and III)	AMA via CMS
RxNorm	Normalized drug names and relationships	NLM
NPI	Provider identifiers (8M+ records)	NPPES
CVX / MVX	Vaccine codes and manufacturers	CDC
UCUM	Units of measure	Regenstrief Institute
MS-DRG	Diagnosis-related groups	CMS
NCCI / MUE	Claims editing rules	CMS

Every endpoint returns structured JSON with consistent response shapes. Every code system is available on every plan, including free.

Five Minutes to Your First API Call

Sign up at fhirfly.io/dashboard, create an API key, and you're making requests. No credit card, no approval queue, no "contact sales."

Option 1: curl

# Look up a drug by NDC code
curl -H "x-api-key: $FHIRFLY_API_KEY" \
  "https://api.fhirfly.io/v1/ndc/0069-0151-01?shape=standard"

{
  "data": {
    "ndc": "0069-0151-01",
    "brand_name": "Lipitor",
    "generic_name": "Atorvastatin Calcium",
    "dosage_form": "TABLET, FILM COATED",
    "strength": "10 mg",
    "route": ["ORAL"],
    "is_active": true,
    "fhir_coding": {
      "system": "http://hl7.org/fhir/sid/ndc",
      "code": "0069-0151-01",
      "display": "Lipitor 10 mg Oral Tablet"
    }
  }
}

Option 2: TypeScript SDK

npm install @fhirfly-io/terminology

import { Fhirfly } from "@fhirfly-io/terminology";

const fhirfly = new Fhirfly({ apiKey: process.env.FHIRFLY_API_KEY! });

// Look up an NDC
const drug = await fhirfly.ndc.lookup("0069-0151-01", { shape: "standard" });
console.log(drug.data.brand_name); // "Lipitor"

// Search ICD-10 codes
const codes = await fhirfly.icd10.search({ q: "type 2 diabetes" }, { limit: 5 });
for (const code of codes.items) {
  console.log(`${code.code}: ${code.display}`);
}
// "E11: Type 2 diabetes mellitus"
// "E11.9: Type 2 diabetes mellitus without complications"
// ...

// Look up a provider by NPI
const provider = await fhirfly.npi.lookup("1234567890");
console.log(provider.data.name); // "SMITH, JOHN MD"

Option 3: MCP (AI Assistants)

FHIRfly ships an MCP server that works with Claude Desktop, Cursor, and other MCP-compatible tools. Install it, add your API key, and your AI assistant can look up medical codes directly:

npx @fhirfly-io/mcp-server --api-key $FHIRFLY_API_KEY

All three access patterns — REST, SDK, and MCP — use the same API key and count against the same monthly quota.

What the Free Tier Actually Gets You

This is the part where most API providers get vague. Here are the exact numbers:

	Free	Developer ($19/mo)
Monthly requests	10,000	100,000
Rate limit	10 req/sec	50 req/sec
Code systems	All 13+	All 13+
Response shapes	compact, standard, full	compact, standard, full
Batch endpoints	Yes	Yes
SDK access	Yes	Yes
MCP access	Yes	Yes
API credentials	Up to 10	Up to 25
Team members	1	5
Audit logs	—	Yes

Notice what's not gated: code systems, response detail, batch endpoints, SDK, and MCP are all included on free. The tiers scale on volume and throughput, not on which data you can access.

10,000 requests per month is enough to build and test an integration, run a side project, or process a moderate claims file using batch endpoints (which count as one request regardless of how many codes you include).

When you outgrow that, the Developer tier at $19/month gives you 10x the volume and 5x the throughput. No contract, cancel anytime.

Real-World Examples

Here's what 10,000 requests/month looks like in practice:

Enrich a Claims File

You have a CSV of pharmacy claims with NDC codes and you need drug names, strengths, and therapeutic classes:

import { Fhirfly } from "@fhirfly-io/terminology";
import { parse } from "csv-parse/sync";
import { readFileSync } from "fs";

const fhirfly = new Fhirfly({ apiKey: process.env.FHIRFLY_API_KEY! });
const claims = parse(readFileSync("claims.csv"), { columns: true });

// Collect unique NDCs and batch-lookup (1 request per 500 codes)
const uniqueNdcs = [...new Set(claims.map((c: any) => c.ndc_code))];

const enriched = await fhirfly.ndc.lookupMany(uniqueNdcs, { shape: "standard" });

const drugMap = new Map(
  enriched.results
    .filter((r) => r.status === "ok")
    .map((r) => [r.input, r.data])
);

for (const claim of claims) {
  const drug = drugMap.get(claim.ndc_code);
  if (drug) {
    claim.drug_name = drug.brand_name || drug.generic_name;
    claim.strength = drug.strength;
    claim.route = drug.route?.join(", ");
  }
}

A file with 2,000 unique NDCs costs 4 batch requests. You could process 500 files like this and still be under the free tier limit.

Validate Diagnosis Codes

Check whether ICD-10 codes on a claim are valid and get their descriptions:

const codes = ["E11.9", "Z79.84", "I10", "FAKE.99"];

const results = await fhirfly.icd10.lookupMany(codes, { shape: "compact" });

for (const result of results.results) {
  if (result.status === "ok") {
    console.log(`${result.input}: ${result.data.display}`);
  } else {
    console.log(`${result.input}: INVALID — ${result.error}`);
  }
}
// "E11.9: Type 2 diabetes mellitus without complications"
// "Z79.84: Long term (current) use of oral hypoglycemic drugs"
// "I10: Essential (primary) hypertension"
// "FAKE.99: INVALID — ICD-10-CM code not found"

One request, four codes validated with descriptions.

Build a Lab Code Autocomplete

Wire up a search endpoint for a clinical UI where users type lab test names:

// User types "hemoglobin a1c"
const results = await fhirfly.loinc.search(
  { q: "hemoglobin a1c", component: "Hemoglobin A1c" },
  { limit: 5, shape: "compact" }
);

for (const item of results.items) {
  console.log(`${item.code}: ${item.display}`);
}
// "4548-4: Hemoglobin A1c/Hemoglobin.total in Blood"
// "17856-6: Hemoglobin A1c/Hemoglobin.total in Blood by HPLC"
// ...

An autocomplete that fires on every keystroke (debounced to 300ms) for 100 users/day would use roughly 3,000 requests/month — comfortably within the free tier.

Why This Doesn't Cost More

Healthcare data vendors have trained the market to expect enterprise pricing because the data curation work is real — normalizing FDA files, mapping across code systems, keeping everything current as CMS publishes quarterly updates. That work has to happen regardless of how many developers use the API.

Where we diverge from the traditional model:

We don't employ a sales team. The pricing is on the website. You sign up, get an API key, and start building. No demos, no "let me loop in my account executive," no 6-week procurement cycles.

We don't charge per code system. Some vendors sell NDC access separately from ICD-10 separately from SNOMED. If your app needs three code systems, you're negotiating three contracts. FHIRfly includes every code system on every plan.

Infrastructure scales efficiently. The API runs on modern cloud infrastructure with aggressive caching. Serving a cached NDC lookup costs us a fraction of a cent. We pass that efficiency through to pricing instead of capturing it as margin.

The data sources are public. Most of the code systems FHIRfly serves — NDC, ICD-10, HCPCS, NPI, CVX, UCUM — come from public-domain government datasets. We believe access to public health data shouldn't require an enterprise budget.

The value we provide is in the accuracy, structure, and freshness of the data — not in locking it behind a paywall.

Data Quality Without Compromise

Low price doesn't mean low quality. Here's what we commit to:

Daily updates. When the FDA publishes new NDC codes, when CMS releases quarterly ICD-10 updates, when NPPES refreshes the provider registry — those changes are reflected in the API the same day. You're not querying a snapshot from last quarter.

Consistent response structure. Every code system returns data in the same JSON shape pattern with the same pagination, error handling, and metadata conventions. Learn one endpoint, and you know them all.

FHIR-ready codings. Every lookup response includes a pre-built fhir_coding object you can drop directly into FHIR R4 resources — MedicationRequest, Condition, Observation, or any resource that accepts a CodeableConcept.

Provenance on every response. The meta object on every response tells you where the data came from, what license applies, and what shape you requested. No guessing about data lineage.

Fast response times. Lookups typically return in 50-85ms server-side for standard shape. Search queries return in 60-160ms depending on the code system and query complexity. Batch endpoints process hundreds of codes in a single round trip — five codes in under 400ms, and the batch counts as one request against your quota.

Getting Started

1. Create an account at fhirfly.io/dashboard — email verification only, no credit card
2. Create an API key in the dashboard under Credentials
3. Install the SDK (optional): npm install @fhirfly-io/terminology
4. Make your first call using any of the examples above
5. Read the docs at fhirfly.io/docs for the complete API reference

If you're building with an AI coding assistant, install the MCP server and your assistant can look up codes for you as you develop.

Key Takeaways

• 13+ code systems from one API — NDC, ICD-10, LOINC, SNOMED, HCPCS, CPT, NPI, RxNorm, CVX, UCUM, MS-DRG, and more
• Free tier includes everything — all code systems, all response shapes, batch endpoints, SDK, and MCP access at 10,000 requests/month
• $19/month Developer tier scales to 100,000 requests/month with 50 req/sec throughput and team access
• Daily-updated data from authoritative sources (FDA, CMS, NLM, CDC) with provenance tracking
• FHIR-native responses — pre-built codings ready for FHIR R4 resources
• No sales calls, no contracts — sign up and start building