openFDA Getting Started: Quickstart Guide (2026)

Getting started overview

The openFDA API provides a standardized interface for accessing various publicly available datasets from the U.S. Food and Drug Administration. These datasets include information on adverse events related to drugs, medical devices, and food products, as well as drug product labeling and enforcement reports openFDA APIs documentation page. This guide focuses on the initial steps for developers to connect to the openFDA API and execute their first successful data retrieval.

Unlike many commercial APIs, openFDA is designed for public access and does not require an API key for standard queries. This simplifies the onboarding process significantly, allowing developers to begin making requests almost immediately after identifying the desired dataset and understanding the query parameters.

The API is designed as a RESTful service, meaning it uses standard HTTP methods (primarily GET) to retrieve resources and returns data in JSON format Mozilla Developer Network's RESTful API explanation. This approach ensures broad compatibility with various programming languages and development environments.

Before making your first request, it's beneficial to understand the types of data available and the basic query structure. The openFDA platform organizes data into distinct endpoints, such as /drug/event for adverse drug events or /device/event for device adverse events. Each endpoint supports specific query parameters for filtering, searching, and pagination.

This getting started guide will walk through accessing the API, constructing a basic query, and interpreting the JSON response. It also includes common next steps and troubleshooting tips to ensure a smooth initial integration experience.

Create an account and get keys

The openFDA API does not require an account or API keys for standard public access openFDA API access details. This means developers can begin making requests immediately without a registration process. This design choice prioritizes ease of access for public health researchers, developers, and organizations seeking to integrate FDA data into their applications or analyses.

While an API key is not necessary for most uses, openFDA does offer an option to request an API key for higher rate limits. By default, requests without an API key are subject to a rate limit of 1,000 requests per hour per IP address. Requesting an API key increases this limit to 10,000 requests per hour per key. This higher limit is beneficial for applications requiring more frequent data access or processing larger volumes of data openFDA getting started documentation.

To obtain an API key, follow these steps:

1. Navigate to the openFDA API Request Key page.
2. Fill out the request form, providing your name, email address, and a brief description of how you intend to use the API.
3. Submit the form. An API key will typically be sent to your email address within a few minutes.

Once you receive your API key, you can include it in your requests using the api_key parameter. However, for initial exploration and smaller-scale projects, the default rate limit without a key is often sufficient.

The absence of mandatory authentication streamlines the initial development phase, allowing for rapid prototyping and testing of API calls. Developers can focus directly on data retrieval and integration logic rather than managing authentication credentials.

Your first request

Making your first request to the openFDA API is straightforward, as no API key is immediately required. This section demonstrates how to construct a basic query using curl, Python, and JavaScript to retrieve data from the /drug/event endpoint.

Basic Query Structure

All openFDA API requests follow a base URL structure: https://api.fda.gov/. To this, you append the desired endpoint and any query parameters. For example, to search for adverse drug events, you would use https://api.fda.gov/drug/event.json.

Query parameters allow you to filter, search, and paginate results. Common parameters include:

• search: To search for specific terms within fields.
• limit: To specify the number of results to return (default is 100, maximum is 1000).
• skip: To paginate results by skipping a specified number of records.

For detailed information on available endpoints and parameters, refer to the openFDA API documentation.

Using curl

curl is a command-line tool for making HTTP requests and is excellent for quick testing.

curl "https://api.fda.gov/drug/event.json?search=patient.drug.medicinalproduct:ibuprofen&limit=1"

This command searches for one adverse drug event where the medicinal product is 'ibuprofen' and limits the results to a single entry. The .json suffix is important to specify the desired output format.

Using Python

Python's requests library simplifies making HTTP requests.

import requests

base_url = "https://api.fda.gov/drug/event.json"
params = {
    "search": "patient.drug.medicinalproduct:ibuprofen",
    "limit": 1
}

response = requests.get(base_url, params=params)
response.raise_for_status() # Raise an exception for HTTP errors
data = response.json()

print(data)

This Python script performs the same query, retrieves the JSON response, and prints it to the console. The raise_for_status() method is a good practice to catch non-2xx HTTP responses.

Using JavaScript (Node.js or Browser)

In Node.js, you can use the built-in https module or a library like node-fetch. In a browser environment, you'd use the fetch API.

// Node.js with node-fetch (install with npm install node-fetch@2)
const fetch = require('node-fetch');

async function getIbuprofenEvent() {
  const url = "https://api.fda.gov/drug/event.json?search=patient.drug.medicinalproduct:ibuprofen&limit=1";
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error("Error fetching data:", error);
  }
}

getIbuprofenEvent();

// Browser Example (using fetch API directly)
/*
async function getIbuprofenEventBrowser() {
  const url = "https://api.fda.gov/drug/event.json?search=patient.drug.medicinalproduct:ibuprofen&limit=1";
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error("Error fetching data:", error);
  }
}

getIbuprofenEventBrowser();
*/

The JavaScript example demonstrates an asynchronous function to fetch data and handle potential errors. Both Node.js and browser environments can successfully interact with the openFDA API.

Common next steps

After successfully making your first request, several common next steps can enhance your use of the openFDA API:

1. Explore more endpoints and datasets

   The openFDA API offers a variety of datasets beyond drug adverse events, including device adverse events, food adverse events, drug product labeling, and recall enforcement reports. Each dataset has unique fields and query capabilities. Reviewing the openFDA API documentation is crucial to understand the full scope of available data.

2. Refine queries with advanced search parameters

   The openFDA API supports powerful search syntax, including boolean operators (AND, OR, NOT), range queries, and field-specific searches. Learning these can help you extract more precise information. For instance, you can search for adverse events reported within a specific date range or for a combination of drugs openFDA query existing data guide.

3. Implement pagination and rate limit handling

   For applications that require retrieving large numbers of records, understanding pagination (using limit and skip parameters) is essential. Additionally, even with an API key, it's important to implement proper rate limiting strategies to avoid exceeding the request limits. This includes exponential backoff for retries AWS documentation on API retries and exponential backoff.

4. Integrate with specific programming languages or tools

   While curl is useful for testing, most applications will integrate the API using a specific programming language. Libraries like Python's requests, JavaScript's fetch, or Ruby's Net::HTTP provide robust ways to interact with RESTful APIs. Consider using a JSON parsing library to easily work with the response data.

5. Request an API key for increased rate limits

   If your application requires more than 1,000 requests per hour, obtain an API key as described in the "Create an account and get keys" section. This will increase your hourly rate limit to 10,000 requests per key, supporting more intensive data processing tasks.

6. Monitor API status and updates

   Stay informed about any changes, maintenance, or new features by monitoring the openFDA announcements. API specifications can evolve, and being aware of updates helps maintain compatibility and leverage new capabilities.

Troubleshooting the first call

Even with a straightforward API like openFDA, initial requests can sometimes encounter issues. Here's a quick reference table and common troubleshooting tips:

Common Error Scenarios and Solutions:

• HTTP 400 Bad Request: This often means your query parameters are malformed or invalid. Double-check the search syntax, field names, and value formats against the openFDA Query Syntax guide.
• HTTP 404 Not Found: Verify the endpoint path in your request. Ensure you're using the correct base URL (api.fda.gov) and the correct endpoint (e.g., /drug/event) with the .json suffix.
• HTTP 429 Too Many Requests: You've exceeded the rate limit (1,000 requests per hour without a key, 10,000 with a key). Wait for the limit to reset, or consider requesting an API key for higher limits. Implement delays or exponential backoff in your code.
• Empty or Unexpected Response: If you get a 200 OK but the results array is empty, your search criteria might be too restrictive or there's no data matching your query. Try broadening your search or simplifying parameters to see if any data returns.
• SSL/TLS Errors: Ensure your environment (e.g., Python's requests, Node.js fetch) has up-to-date SSL certificates and can connect to HTTPS endpoints securely. This is rarely an issue in modern environments but can occur in older systems.

When in doubt, start with the simplest possible query (e.g., https://api.fda.gov/drug/event.json?limit=1) to confirm basic connectivity, and then incrementally add your desired parameters, testing each addition.