DailyMed API Skill

What this data is: The official FDA-approved labeling for prescription drugs, OTC drugs, biologics, and some medical devices. Labels include prescribing information, medication guides, patient package inserts, and boxed warnings. Data is submitted by manufacturers via SPL (Structured Product Labeling, an HL7 standard) and published by NLM. Updated daily.

What this data is NOT: Not adverse event data (use openFDA FAERS for that). Not approval history (use openFDA Drugs@FDA). Not market wage or pricing data. DailyMed is specifically the labeling text and associated metadata (NDCs, ingredients, drug classes, images).

Relationship to openFDA: openFDA's drug/label endpoint carries a subset of DailyMed data (searchable labeling sections like boxed_warning, indications_and_usage). DailyMed provides the complete SPL record, version history, NDC packaging details, pill images, and structured ingredient/drug class data that openFDA does not expose.

Rate Limits

No published rate limit, but DailyMed is a shared NLM resource. Add time.sleep(0.5) between requests in batch operations. Excessive automated traffic may be throttled.

Core Helper Function

import urllib.request, urllib.parse, json

BASE = "https://dailymed.nlm.nih.gov/dailymed/services/v2"

def dailymed_query(endpoint, params=None):
    """Query DailyMed API v2. Returns parsed JSON."""
    url = f"{BASE}/{endpoint}.json"
    if params:
        params = {k: v for k, v in params.items() if v is not None}
        url += "?" + urllib.parse.urlencode(params)
    req = urllib.request.Request(url, headers={"Accept": "application/json"})
    with urllib.request.urlopen(req, timeout=15) as resp:
        return json.loads(resp.read().decode())

Endpoints

1. Search SPLs (Drug Labels) -- PRIMARY WORKHORSE

Endpoint: GET /spls.json

Search for drug labels by name, RXCUI, UNII code, setid, or drug class.

Parameters:

def search_labels(drug_name=None, rxcui=None, unii_code=None, setid=None,
                  pagesize=10, page=1):
    """Search DailyMed drug labels."""
    params = {"pagesize": pagesize, "page": page}
    if drug_name: params["drug_name"] = drug_name
    if rxcui: params["rxcui"] = rxcui
    if unii_code: params["unii_code"] = unii_code
    if setid: params["setid"] = setid
    return dailymed_query("spls", params)

Response: Returns paginated list of labels with setid, spl_version, title, and published_date.

2. SPL Sub-Resources (by Set ID)

Once you have a setid from search, you can access detailed sub-resources:

NDCs (National Drug Codes)

Endpoint: GET /spls/{setid}/ndcs.json

Returns all NDC codes associated with a label.

def get_ndcs(setid):
    """Get NDC codes for a specific label."""
    return dailymed_query(f"spls/{setid}/ndcs")

Response includes title, spl_version, and ndcs array with ndc strings.

Packaging Details

Endpoint: GET /spls/{setid}/packaging.json

Returns detailed packaging information including active ingredients and strengths.

def get_packaging(setid):
    """Get packaging details including ingredients and strengths."""
    return dailymed_query(f"spls/{setid}/packaging")

Response includes products array, each with packaging (NDC + package descriptions) and active_ingredients (name + strength).

Media (Pill Images)

Endpoint: GET /spls/{setid}/media.json

Returns images associated with a label (pill photos, packaging images).

def get_media(setid):
    """Get images for a drug label."""
    return dailymed_query(f"spls/{setid}/media")

Response includes media array with name, mime_type, and url.

Version History

Endpoint: GET /spls/{setid}/history.json

Returns the publication history of a label, showing when each version was published.

def get_history(setid):
    """Get label version history."""
    return dailymed_query(f"spls/{setid}/history")

Response includes spl (title and setid) and history array with spl_version and published_date for each version.

3. Drug Names

Endpoint: GET /drugnames.json

Search for drug names and identify brand vs. generic.

def search_drug_names(drug_name, pagesize=20):
    """Search drug names. Returns brand (B) and generic (G) name types."""
    return dailymed_query("drugnames", {"drug_name": drug_name, "pagesize": pagesize})

Response field name_type: B = brand name, G = generic name.

4. RXCUIs

Endpoint: GET /rxcuis.json

List or search RxNorm Concept Unique Identifiers mapped to DailyMed labels.

def search_rxcuis(rxstring=None, rxtty=None, rxcui=None, pagesize=20):
    """Search RXCUIs in DailyMed."""
    params = {"pagesize": pagesize}
    if rxstring: params["rxstring"] = rxstring
    if rxtty: params["rxtty"] = rxtty
    if rxcui: params["rxcui"] = rxcui
    return dailymed_query("rxcuis", params)

5. UNIIs (Ingredient Identifiers)

Endpoint: GET /uniis.json

Search Unique Ingredient Identifiers. UNIIs are FDA's standard for identifying active ingredients.

def search_uniis(active_moiety=None, unii_code=None, pagesize=20):
    """Search UNII ingredient identifiers."""
    params = {"pagesize": pagesize}
    if active_moiety: params["active_moiety"] = active_moiety
    if unii_code: params["unii_code"] = unii_code
    return dailymed_query("uniis", params)

6. Drug Classes

Endpoint: GET /drugclasses.json

List pharmacologic drug classes (Established Pharmacologic Class, or EPC, from NDF-RT).

def list_drug_classes(pagesize=100):
    """List all drug classes."""
    return dailymed_query("drugclasses", {"pagesize": pagesize})

Response fields: code, codingSystem, type (EPC), name (class name).

Response Structure

All endpoints return this wrapper:

{
  "metadata": {
    "total_elements": 544,
    "elements_per_page": 10,
    "total_pages": 55,
    "current_page": 1,
    "current_url": "...",
    "next_page": 2,
    "next_page_url": "...",
    "db_published_date": "Mar 11, 2026 07:38:49PM EST"
  },
  "data": [ ... ]
}

Sub-resource endpoints (/ndcs, /packaging, /media, /history) return data as an object (not array) containing the label-specific details.

Common Workflows

Look Up a Drug Label

def find_label(drug_name):
    """Find labels for a drug by name."""
    r = search_labels(drug_name=drug_name, pagesize=5)
    labels = r.get("data", [])
    return [{
        "setid": l["setid"],
        "title": l["title"],
        "version": l["spl_version"],
        "published": l["published_date"]
    } for l in labels]

Get Complete Product Info (Label + NDCs + Ingredients)

import time

def product_detail(drug_name):
    """Get label, NDCs, active ingredients, and images for a drug."""
    # Find the label
    r = search_labels(drug_name=drug_name, pagesize=1)
    if not r.get("data"):
        return None
    
    setid = r["data"][0]["setid"]
    title = r["data"][0]["title"]
    
    time.sleep(0.5)
    packaging = get_packaging(setid)
    
    time.sleep(0.5)
    ndcs = get_ndcs(setid)
    
    time.sleep(0.5)
    media = get_media(setid)
    
    products = packaging.get("data", {}).get("products", [])
    ingredients = []
    for p in products:
        for ai in p.get("active_ingredients", []):
            ingredients.append(f"{ai['name']} {ai['strength']}")
    
    ndc_list = [n["ndc"] for n in ndcs.get("data", {}).get("ndcs", [])]
    image_urls = [m["url"] for m in media.get("data", {}).get("media", [])]
    
    return {
        "title": title,
        "setid": setid,
        "active_ingredients": ingredients,
        "ndcs": ndc_list,
        "images": image_urls
    }

Track Label Revision History

def label_history(drug_name):
    """Get the revision history for a drug's labeling."""
    r = search_labels(drug_name=drug_name, pagesize=1)
    if not r.get("data"):
        return None
    
    setid = r["data"][0]["setid"]
    history = get_history(setid)
    
    return {
        "title": history.get("data", {}).get("spl", {}).get("title"),
        "versions": history.get("data", {}).get("history", [])
    }

Find All Products Containing an Ingredient (by UNII)

def products_by_ingredient(unii_code, pagesize=20):
    """Find all labeled products containing a specific ingredient."""
    return search_labels(unii_code=unii_code, pagesize=pagesize)

Cross-Reference RXCUI to Labels

def labels_by_rxcui(rxcui, pagesize=10):
    """Find all DailyMed labels mapped to a specific RXCUI."""
    return search_labels(rxcui=rxcui, pagesize=pagesize)

Pagination

Standard page-based pagination. All list endpoints support pagesize (max 100) and page parameters.

import time

def paginate_labels(max_results=500, **search_kwargs):
    """Paginate through label search results."""
    all_labels = []
    page = 1
    while len(all_labels) < max_results:
        r = search_labels(**search_kwargs, pagesize=100, page=page)
        data = r.get("data", [])
        if not data:
            break
        all_labels.extend(data)
        total_pages = r.get("metadata", {}).get("total_pages", 1)
        if page >= total_pages:
            break
        page += 1
        time.sleep(0.5)
    return all_labels[:max_results]

Gotchas and Best Practices

1. SPL Detail Returns 415 for JSON (MOST COMMON MISTAKE)

The /spls/{setid}.json endpoint (fetching a single SPL record directly) returns HTTP 415 Unsupported Media Type. There is no JSON detail view for individual SPLs. Instead, use the sub-resource endpoints (/ndcs, /packaging, /media, /history) to get detailed information, or use the search endpoint with the setid parameter.

2. Formats: Append .json or .xml

All endpoints support both JSON and XML. Append .json or .xml to the endpoint path. Default without extension varies. Always specify .json explicitly.

3. Drug Name Search is Broad

Searching drug_name=metformin returns all labels containing metformin in the title, including combination products (e.g., "GLIPIZIDE AND METFORMIN HYDROCHLORIDE"). Use the response title to filter for exact matches.

4. SetID is the Stable Identifier

The setid (a UUID) is the permanent identifier for a drug label. It persists across version updates. SPL versions increment as the label is revised, but the setid stays the same. Always reference labels by setid, not by title.

5. NDC Sub-Resource Returns Object, Not Array

The /spls/{setid}/ndcs.json response has data as an object (with title, spl_version, ndcs array inside), not as a top-level array. Same for /packaging, /media, and /history.

6. Drug Class Data Uses NDF-RT Codes

Drug class codes follow the NDF-RT (National Drug File Reference Terminology) system. The codes are NUI identifiers like N0000175580. The type field is typically EPC (Established Pharmacologic Class).

7. UNII Search Does Not Filter by Drug Name

The /uniis.json endpoint with drug_name param searches across ALL UNIIs, not just those in products matching that name. Use unii_code for specific lookups, or search /spls.json by unii_code to find products containing a specific ingredient.

8. Published Dates Are Strings

Dates appear as formatted strings like "Apr 03, 2025", not ISO format. Parse with care if doing date comparisons.

9. pagesize Max is 100

Unlike some APIs with 1000-record pages, DailyMed caps at 100 per page. Plan pagination accordingly for large result sets.

10. Apostrophes in Drug Names Return Zero Results

The drug_name parameter does not handle apostrophes. Searching drug_name=Children's Motrin returns 0 results. Drop the apostrophe (Childrens Motrin returns 6) or use just the base name (Motrin returns 22). This also applies to names like "Crohn's" or "Graves'".

11. drug_class_code REQUIRES drug_class_coding_system (RETURNS 0 WITHOUT IT)

Searching /spls.json?drug_class_code=N0000175589 without also passing drug_class_coding_system=2.16.840.1.113883.6.345 returns zero results with no error message. The coding system parameter is mandatory, not optional. Always include both:

/spls.json?drug_class_code=N0000175589&drug_class_coding_system=2.16.840.1.113883.6.345

12. Sub-Resource Metadata is Inconsistent

The /ndcs sub-resource includes total_elements, total_pages, etc. in its metadata. The /packaging, /media, and /history sub-resources do NOT. They only return db_published_date and current_url in metadata. Check for empty arrays in the data object (ndcs: [], products: [], media: [], history: []) rather than relying on total_elements to detect empty results.

Troubleshooting