Agent skill

openFDA Regulatory Data Queries

by davila7 in davila7/claude-code-templates

Queries the openFDA API from Python for drug, device, food and veterinary data: adverse events, recalls, labels, approvals, NDC and UNII lookups.

MITAuto-check passedData & Analytics

Install openFDA Regulatory Data Queries

skills CLI
$ npx skills add davila7/claude-code-templates --skill fda-database -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install davila7/claude-code-templates fda-database --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/davila7/claude-code-templates.git skills-src && mkdir -p .claude/skills && cp -r skills-src/cli-tool/components/skills/scientific/fda-database .claude/skills/fda-database && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
fda-database
GitHub stars
32k
Used in
12 other repos
Token cost
~3.6k tokens
SKILL.md length
780 words
Files
9 (incl. scripts, references)
Skills in repo
477
Repo updated
First seen
Licence
MIT

At a glance

Queries the openFDA API from Python for drug, device, food and veterinary data: adverse events, recalls, labels, approvals, NDC and UNII lookups.

  • Works in 8 steps: Basic Setup → API Key Setup → Running Examples → …
  • Checking the adverse event history of a drug before a safety review
  • SKILL.md covers Overview, When to Use This Skill, Quick Start and FDA Database Categories, plus 5 more sections
  • Runs Python scripts from its folder; calls python; needs FDA_API_KEY

What it does

The skill gives the agent a Python workflow for the public openFDA API, which covers drugs, medical devices, foods, animal and veterinary products, and substances. A `FDAQuery` helper in `scripts/fda_query.py` makes the requests, `scripts/fda_examples.py` shows worked examples, and separate reference files describe API basics and each product area.

Typical jobs include pulling adverse event reports, checking labeling and approvals, following recalls and enforcement actions, looking up National Drug Codes and UNII substance identifiers, and reviewing 510k and PMA device clearances. The API works without a key; registering one raises the daily limit from 1,000 to 120,000 requests while the per-minute limit stays at 240. The key is passed through the `FDA_API_KEY` environment variable.

When your agent uses it

  • Checking the adverse event history of a drug before a safety review
  • Looking up a device's 510k clearance or recall record
  • Mapping a substance name to its UNII identifier or CAS number
  • Tracking food recalls and allergen-related enforcement actions

Example prompts

  • “Pull the most reported adverse events for metformin from openFDA and summarize them in a table.”
  • “Find recalls for insulin pumps in the last two years and group them by reason.”
  • “Look up the NDC listing for ibuprofen tablets and list the manufacturers.”

Requirements

  • Python
  • Network access to the openFDA API
  • An openFDA API key (optional, raises the daily request limit)

Workflow steps

8 steps, taken from the step headings in SKILL.md.

  1. Basic Setup
  2. API Key Setup
  3. Running Examples
  4. Use Specific Searches
  5. Implement Rate Limiting
  6. Cache Frequently Accessed Data
  7. Use Exact Matching for Counting
  8. Validate Input Data

What it can do on your machine

Read from SKILL.md and the folder at commit 4c82aba. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • open.fda.gov
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • FDA_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

openFDA Regulatory Data Queries loads about 3.6k tokens when it runs, and up to ~25k if it reads all its reference files. Until then it costs about 50 tokens; SKILL.md has 780 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~50
When it runs · the whole SKILL.md, loaded when a task matches
~3.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~25k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from davila7/claude-code-templates at commit 4c82aba, republished under its MIT licence (© davila7). 780 words, ~3,589 tokens.

Download SKILL.mdSave it as .claude/skills/fda-database/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
fda-database
description
Query openFDA API for drugs, devices, adverse events, recalls, regulatory submissions (510k, PMA), substance identification (UNII), for FDA regulatory data analysis and safety research.

FDA Database Access

Overview

Access comprehensive FDA regulatory data through openFDA, the FDA's initiative to provide open APIs for public datasets. Query information about drugs, medical devices, foods, animal/veterinary products, and substances using Python with standardized interfaces.

Key capabilities:

  • Query adverse events for drugs, devices, foods, and veterinary products
  • Access product labeling, approvals, and regulatory submissions
  • Monitor recalls and enforcement actions
  • Look up National Drug Codes (NDC) and substance identifiers (UNII)
  • Analyze device classifications and clearances (510k, PMA)
  • Track drug shortages and supply issues
  • Research chemical structures and substance relationships

When to Use This Skill

This skill should be used when working with:

  • Drug research: Safety profiles, adverse events, labeling, approvals, shortages
  • Medical device surveillance: Adverse events, recalls, 510(k) clearances, PMA approvals
  • Food safety: Recalls, allergen tracking, adverse events, dietary supplements
  • Veterinary medicine: Animal drug adverse events by species and breed
  • Chemical/substance data: UNII lookup, CAS number mapping, molecular structures
  • Regulatory analysis: Approval pathways, enforcement actions, compliance tracking
  • Pharmacovigilance: Post-market surveillance, safety signal detection
  • Scientific research: Drug interactions, comparative safety, epidemiological studies

Quick Start

1. Basic Setup
python
from scripts.fda_query import FDAQuery

# Initialize (API key optional but recommended)
fda = FDAQuery(api_key="YOUR_API_KEY")

# Query drug adverse events
events = fda.query_drug_events("aspirin", limit=100)

# Get drug labeling
label = fda.query_drug_label("Lipitor", brand=True)

# Search device recalls
recalls = fda.query("device", "enforcement",
                   search="classification:Class+I",
                   limit=50)
2. API Key Setup

While the API works without a key, registering provides higher rate limits:

  • Without key: 240 requests/min, 1,000/day
  • With key: 240 requests/min, 120,000/day

Register at: https://open.fda.gov/apis/authentication/

Set as environment variable:

bash
export FDA_API_KEY="your_key_here"
3. Running Examples
bash
# Run comprehensive examples
python scripts/fda_examples.py

# This demonstrates:
# - Drug safety profiles
# - Device surveillance
# - Food recall monitoring
# - Substance lookup
# - Comparative drug analysis
# - Veterinary drug analysis

FDA Database Categories

Drugs

Access 6 drug-related endpoints covering the full drug lifecycle from approval to post-market surveillance.

Endpoints:

  1. Adverse Events - Reports of side effects, errors, and therapeutic failures
  2. Product Labeling - Prescribing information, warnings, indications
  3. NDC Directory - National Drug Code product information
  4. Enforcement Reports - Drug recalls and safety actions
  5. Drugs@FDA - Historical approval data since 1939
  6. Drug Shortages - Current and resolved supply issues

Common use cases:

python
# Safety signal detection
fda.count_by_field("drug", "event",
                  search="patient.drug.medicinalproduct:metformin",
                  field="patient.reaction.reactionmeddrapt")

# Get prescribing information
label = fda.query_drug_label("Keytruda", brand=True)

# Check for recalls
recalls = fda.query_drug_recalls(drug_name="metformin")

# Monitor shortages
shortages = fda.query("drug", "drugshortages",
                     search="status:Currently+in+Shortage")

Reference: See references/drugs.md for detailed documentation

Devices

Access 9 device-related endpoints covering medical device safety, approvals, and registrations.

Endpoints:

  1. Adverse Events - Device malfunctions, injuries, deaths
  2. 510(k) Clearances - Premarket notifications
  3. Classification - Device categories and risk classes
  4. Enforcement Reports - Device recalls
  5. Recalls - Detailed recall information
  6. PMA - Premarket approval data for Class III devices
  7. Registrations & Listings - Manufacturing facility data
  8. UDI - Unique Device Identification database
  9. COVID-19 Serology - Antibody test performance data

Common use cases:

python
# Monitor device safety
events = fda.query_device_events("pacemaker", limit=100)

# Look up device classification
classification = fda.query_device_classification("DQY")

# Find 510(k) clearances
clearances = fda.query_device_510k(applicant="Medtronic")

# Search by UDI
device_info = fda.query("device", "udi",
                       search="identifiers.id:00884838003019")

Reference: See references/devices.md for detailed documentation

Foods

Access 2 food-related endpoints for safety monitoring and recalls.

Endpoints:

  1. Adverse Events - Food, dietary supplement, and cosmetic events
  2. Enforcement Reports - Food product recalls

Common use cases:

python
# Monitor allergen recalls
recalls = fda.query_food_recalls(reason="undeclared peanut")

# Track dietary supplement events
events = fda.query_food_events(
    industry="Dietary Supplements")

# Find contamination recalls
listeria = fda.query_food_recalls(
    reason="listeria",
    classification="I")

Reference: See references/foods.md for detailed documentation

Animal & Veterinary

Access veterinary drug adverse event data with species-specific information.

Endpoint:

  1. Adverse Events - Animal drug side effects by species, breed, and product

Common use cases:

python
# Species-specific events
dog_events = fda.query_animal_events(
    species="Dog",
    drug_name="flea collar")

# Breed predisposition analysis
breed_query = fda.query("animalandveterinary", "event",
    search="reaction.veddra_term_name:*seizure*+AND+"
           "animal.breed.breed_component:*Labrador*")

Reference: See references/animal_veterinary.md for detailed documentation

Substances & Other

Access molecular-level substance data with UNII codes, chemical structures, and relationships.

Endpoints:

  1. Substance Data - UNII, CAS, chemical structures, relationships
  2. NSDE - Historical substance data (legacy)

Common use cases:

python
# UNII to CAS mapping
substance = fda.query_substance_by_unii("R16CO5Y76E")

# Search by name
results = fda.query_substance_by_name("acetaminophen")

# Get chemical structure
structure = fda.query("other", "substance",
    search="names.name:ibuprofen+AND+substanceClass:chemical")

Reference: See references/other.md for detailed documentation

Show full SKILL.md (306 more words)Show less

Common Query Patterns

Pattern 1: Safety Profile Analysis

Create comprehensive safety profiles combining multiple data sources:

python
def drug_safety_profile(fda, drug_name):
    """Generate complete safety profile."""

    # 1. Total adverse events
    events = fda.query_drug_events(drug_name, limit=1)
    total = events["meta"]["results"]["total"]

    # 2. Most common reactions
    reactions = fda.count_by_field(
        "drug", "event",
        search=f"patient.drug.medicinalproduct:*{drug_name}*",
        field="patient.reaction.reactionmeddrapt",
        exact=True
    )

    # 3. Serious events
    serious = fda.query("drug", "event",
        search=f"patient.drug.medicinalproduct:*{drug_name}*+AND+serious:1",
        limit=1)

    # 4. Recent recalls
    recalls = fda.query_drug_recalls(drug_name=drug_name)

    return {
        "total_events": total,
        "top_reactions": reactions["results"][:10],
        "serious_events": serious["meta"]["results"]["total"],
        "recalls": recalls["results"]
    }
Pattern 2: Temporal Trend Analysis

Analyze trends over time using date ranges:

python
from datetime import datetime, timedelta

def get_monthly_trends(fda, drug_name, months=12):
    """Get monthly adverse event trends."""
    trends = []

    for i in range(months):
        end = datetime.now() - timedelta(days=30*i)
        start = end - timedelta(days=30)

        date_range = f"[{start.strftime('%Y%m%d')}+TO+{end.strftime('%Y%m%d')}]"
        search = f"patient.drug.medicinalproduct:*{drug_name}*+AND+receivedate:{date_range}"

        result = fda.query("drug", "event", search=search, limit=1)
        count = result["meta"]["results"]["total"] if "meta" in result else 0

        trends.append({
            "month": start.strftime("%Y-%m"),
            "events": count
        })

    return trends
Pattern 3: Comparative Analysis

Compare multiple products side-by-side:

python
def compare_drugs(fda, drug_list):
    """Compare safety profiles of multiple drugs."""
    comparison = {}

    for drug in drug_list:
        # Total events
        events = fda.query_drug_events(drug, limit=1)
        total = events["meta"]["results"]["total"] if "meta" in events else 0

        # Serious events
        serious = fda.query("drug", "event",
            search=f"patient.drug.medicinalproduct:*{drug}*+AND+serious:1",
            limit=1)
        serious_count = serious["meta"]["results"]["total"] if "meta" in serious else 0

        comparison[drug] = {
            "total_events": total,
            "serious_events": serious_count,
            "serious_rate": (serious_count/total*100) if total > 0 else 0
        }

    return comparison
Pattern 4: Cross-Database Lookup

Link data across multiple endpoints:

python
def comprehensive_device_lookup(fda, device_name):
    """Look up device across all relevant databases."""

    return {
        "adverse_events": fda.query_device_events(device_name, limit=10),
        "510k_clearances": fda.query_device_510k(device_name=device_name),
        "recalls": fda.query("device", "enforcement",
                           search=f"product_description:*{device_name}*"),
        "udi_info": fda.query("device", "udi",
                            search=f"brand_name:*{device_name}*")
    }

Working with Results

Response Structure

All API responses follow this structure:

python
{
    "meta": {
        "disclaimer": "...",
        "results": {
            "skip": 0,
            "limit": 100,
            "total": 15234
        }
    },
    "results": [
        # Array of result objects
    ]
}
Error Handling

Always handle potential errors:

python
result = fda.query_drug_events("aspirin", limit=10)

if "error" in result:
    print(f"Error: {result['error']}")
elif "results" not in result or len(result["results"]) == 0:
    print("No results found")
else:
    # Process results
    for event in result["results"]:
        # Handle event data
        pass
Pagination

For large result sets, use pagination:

python
# Automatic pagination
all_results = fda.query_all(
    "drug", "event",
    search="patient.drug.medicinalproduct:aspirin",
    max_results=5000
)

# Manual pagination
for skip in range(0, 1000, 100):
    batch = fda.query("drug", "event",
                     search="...",
                     limit=100,
                     skip=skip)
    # Process batch

Best Practices

1. Use Specific Searches

DO:

python
# Specific field search
search="patient.drug.medicinalproduct:aspirin"

DON'T:

python
# Overly broad wildcard
search="*aspirin*"
2. Implement Rate Limiting

The FDAQuery class handles rate limiting automatically, but be aware of limits:

  • 240 requests per minute
  • 120,000 requests per day (with API key)
3. Cache Frequently Accessed Data

The FDAQuery class includes built-in caching (enabled by default):

python
# Caching is automatic
fda = FDAQuery(api_key=api_key, use_cache=True, cache_ttl=3600)
4. Use Exact Matching for Counting

When counting/aggregating, use .exact suffix:

python
# Count exact phrases
fda.count_by_field("drug", "event",
                  search="...",
                  field="patient.reaction.reactionmeddrapt",
                  exact=True)  # Adds .exact automatically
5. Validate Input Data

Clean and validate search terms:

python
def clean_drug_name(name):
    """Clean drug name for query."""
    return name.strip().replace('"', '\\"')

drug_name = clean_drug_name(user_input)

API Reference

For detailed information about:

  • Authentication and rate limits → See references/api_basics.md
  • Drug databases → See references/drugs.md
  • Device databases → See references/devices.md
  • Food databases → See references/foods.md
  • Animal/veterinary databases → See references/animal_veterinary.md
  • Substance databases → See references/other.md

Scripts

scripts/fda_query.py

Main query module with FDAQuery class providing:

  • Unified interface to all FDA endpoints
  • Automatic rate limiting and caching
  • Error handling and retry logic
  • Common query patterns
scripts/fda_examples.py

Comprehensive examples demonstrating:

  • Drug safety profile analysis
  • Device surveillance monitoring
  • Food recall tracking
  • Substance lookup
  • Comparative drug analysis
  • Veterinary drug analysis

Run examples:

bash
python scripts/fda_examples.py

Additional Resources

Support and Troubleshooting

Common Issues

Issue: Rate limit exceeded

  • Solution: Use API key, implement delays, or reduce request frequency

Issue: No results found

  • Solution: Try broader search terms, check spelling, use wildcards

Issue: Invalid query syntax

  • Solution: Review query syntax in references/api_basics.md

Issue: Missing fields in results

  • Solution: Not all records contain all fields; always check field existence
Getting Help

© davila7, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 8 other files (scripts, references) in cli-tool/components/skills/scientific/fda-database of davila7/claude-code-templates.

  • SKILL.md
  • references/animal_veterinary.md
  • references/api_basics.md
  • references/devices.md
  • references/drugs.md
  • references/foods.md
  • references/other.md
  • scripts/fda_examples.py
  • scripts/fda_query.py

Open the folder on GitHubat commit 4c82aba

Used in 12 other repositories

We found 22 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 12 other GitHub owners. This page covers the copy in davila7/claude-code-templates, which our catalogue first saw on October 7, 2026.

Compare with similar skills

openFDA Regulatory Data Queries next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

openFDA Regulatory Data Queries compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
openFDA Regulatory Data Queries this skilldavila7/claude-code-templates32k12 repos~3.6kAutomated safety check: PassMIT
Statistical Data Analysislingzhi227/agent-research-skills383—~886Automated safety check: PassNone
Q-EDA Exploratory AnalysisTyrealQ/q-skills108—~1.1kAutomated safety check: PassMIT
Analyzebrycewang-stanford/Auto-Empirical-Research-Skills4.5k—~2.2kAutomated safety check: NotesCustom licence
Excel and CSV Data Analysisbytedance/deer-flow83k4 repos~2.2kAutomated safety check: PassMIT
Python Executorcortega26/chile-hub1132 repos~1.5kAutomated safety check: PassMIT

Similar skills

  • Statistical Data Analysis

    lingzhi227/agent-research-skills

    Writes statistical analysis code for experimental data, runs it through a four-round review, and reports effect sizes, p-values and confidence intervals.

    383 GitHub stars~886 tokensUpdated 7 mo ago
    Data & AnalyticsAuto-check passed
  • Runs exploratory data analysis on tabular data after you confirm each column's measurement level, then writes CSV tables and a narrative summary.

    108 GitHub stars~1.1k tokensUpdated 14 days ago
    Data & AnalyticsAuto-check passed
  • Analyze

    brycewang-stanford/Auto-Empirical-Research-Skills

    End-to-end data analysis dispatching Coder and Data-engineer for implementation, coder-critic for review.

    4.5k GitHub stars~2.2k tokensUpdated 2 days ago
    Data & AnalyticsAuto-check: notes
  • Excel and CSV Data Analysis

    bytedance/deer-flow

    Analyzes uploaded Excel and CSV files with SQL through DuckDB, producing schema inspections, statistical summaries and exports to CSV, JSON or Markdown.

    83k GitHub starsUsed in 4 repos~2.2k tokens
    Data & AnalyticsAuto-check passed
  • Python Executor

    cortega26/chile-hub

    Execute Python code in a safe sandboxed environment via [inference.sh](https://inference.sh).

    113 GitHub starsUsed in 2 repos~1.5k tokens
    Data & AnalyticsAuto-check passed
  • Matlab

    zLanqing/codex-claude-academic-skills

    MATLAB and GNU Octave numerical computing for matrix operations, data analysis, visualization, and scientific computing.

    4.6k GitHub starsUsed in 9 repos~2.3k tokens
    Data & AnalyticsAuto-check: notes

More from davila7/claude-code-templates

All 477 skills in this repo
  • Perplexity Web Search

    davila7/claude-code-templates

    Runs web-grounded searches through Perplexity's Sonar models over OpenRouter for current events, recent literature and cited facts beyond the model's training cutoff.

    32k GitHub starsUsed in 12 repos~3.5k tokens
    Auto-check: notes
  • Neuropixels Data Analysis

    davila7/claude-code-templates

    Analyzes Neuropixels recordings from SpikeGLX or Open Ephys through preprocessing, drift correction, Kilosort4 spike sorting, quality metrics and curation.

    32k GitHub starsUsed in 10 repos~2.8k tokens
    Auto-check passed
  • Scientific Venue Templates

    davila7/claude-code-templates

    Supplies LaTeX templates and formatting rules for journals, conferences, posters, and grant proposals, then can check a draft against them.

    32k GitHub starsUsed in 9 repos~5.1k tokens
    Auto-check: notes
  • Brand Voice Content Creator

    davila7/claude-code-templates

    Analyzes a brand's existing writing to lock in a consistent voice, then builds SEO blog posts and platform-specific social content around it.

    32k GitHub starsUsed in 2 repos~1.9k tokens
    Auto-check passed
  • CAPA Officer

    davila7/claude-code-templates

    Guides corrective and preventive action (CAPA) work in a quality management system, from initiation and root cause analysis through effectiveness verification.

    32k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed
  • Fda Consultant Specialist

    davila7/claude-code-templates

    Senior FDA consultant and specialist for medical device companies including HIPAA compliance and requirement management.

    32k GitHub starsUsed in 1 repo~2.7k tokens
    Auto-check passed

Works with

Questions about openFDA Regulatory Data Queries

What does openFDA Regulatory Data Queries do?

Queries the openFDA API from Python for drug, device, food and veterinary data: adverse events, recalls, labels, approvals, NDC and UNII lookups. The skill gives the agent a Python workflow for the public openFDA API, which covers drugs, medical devices, foods, animal and veterinary products, and substances.py` shows worked examples, and separate reference files describe API basics and each product area.

When should I use openFDA Regulatory Data Queries?

openFDA Regulatory Data Queries fits situations like: checking the adverse event history of a drug before a safety review; looking up a device's 510k clearance or recall record; mapping a substance name to its UNII identifier or CAS number; tracking food recalls and allergen-related enforcement actions.

How do I install openFDA Regulatory Data Queries in Claude Code?

Run `npx skills add davila7/claude-code-templates --skill fda-database -a claude-code`. Or copy the skill folder (cli-tool/components/skills/scientific/fda-database in davila7/claude-code-templates) into .claude/skills/fda-database in your project. Claude Code loads it when a task matches its description.

How do I install openFDA Regulatory Data Queries in Codex?

Run `npx skills add davila7/claude-code-templates --skill fda-database -a codex`. Or copy the skill folder (cli-tool/components/skills/scientific/fda-database in davila7/claude-code-templates) into .agents/skills/fda-database in your project. Codex loads it when a task matches its description.

Can I use openFDA Regulatory Data Queries in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add davila7/claude-code-templates --skill fda-database -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/fda-database, .gemini/skills/fda-database, .github/skills/fda-database and .opencode/skills/fda-database in your project.

What does openFDA Regulatory Data Queries need to run?

Going by SKILL.md and its folder, openFDA Regulatory Data Queries needs Python for the scripts in its folder, the command-line tools its instructions call (python) and credentials named FDA_API_KEY. Our summary lists: Python; Network access to the openFDA API; An openFDA API key (optional, raises the daily request limit).

Does openFDA Regulatory Data Queries access the network?

SKILL.md names 2 domains. As links in the text: open.fda.gov and github.com. This is read from the text; nothing was executed.

Is openFDA Regulatory Data Queries safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does openFDA Regulatory Data Queries use?

openFDA Regulatory Data Queries is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does openFDA Regulatory Data Queries use?

About 3.6k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 21k tokens, read only when the agent opens those files.

What are the alternatives to openFDA Regulatory Data Queries?

Skills that share tags, products or a category with openFDA Regulatory Data Queries: Statistical Data Analysis (lingzhi227/agent-research-skills, 383 stars), Q-EDA Exploratory Analysis (TyrealQ/q-skills, 108 stars), Analyze (brycewang-stanford/Auto-Empirical-Research-Skills, 4.5k stars) and Excel and CSV Data Analysis (bytedance/deer-flow, 83k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains openFDA Regulatory Data Queries?

davila7 (a GitHub user) maintains it in davila7/claude-code-templates, which has 32,432 GitHub stars. The repository holds 477 skills in this directory. The repository was last updated on October 7, 2026.

Source: davila7/claude-code-templates on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.