DEV Community: Rahul Ban

How I Built Clinical Trials API - From Public Data to RapidAPI in 2 Weeks

Rahul Ban — Sun, 24 May 2026 16:09:11 +0000

ClinicalTrials.gov - the U.S. government's registry of every FDA clinical trial - publishes 480,000+ studies as public domain data, updated daily. It's one of the most valuable datasets in healthcare. Pharma companies, CROs, healthtech startups, and academic researchers all need this data programmatically.

But the official ClinicalTrials.gov API v2? It's essentially a REST wrapper around a search engine built for human researchers. No structured eligibility parsing. No geographic radius search. No webhook alerts. Pagination that breaks when you change parameters mid-pagination. If you want to build anything beyond a basic keyword search, you end up scraping the website, downloading 2GB text file exports, or paying enterprise vendors $500+/month.

So I built the Clinical Trials API - a proper REST layer on top of ClinicalTrials.gov with structured eligibility, geo search, and webhook alerts. Here's how it went.

The Stack

Runtime: Python Workers (Pyodide, Redux memory snapshots)
Deployment: Wrangler CLI -> 330+ edge locations worldwide
Backend Data: ClinicalTrials.gov API v2 (public domain, no auth required)
Marketplace & Billing: RapidAPI
Pricing: Free / $49/mo (Pro) / $199/mo (Ultra)
Average Response: 350-500ms warm, ~1s cold start

What I Built

10 endpoints across 4 functional groups:

Endpoint	Description	Tier
GET /v1/trials/search	Full-text + fielded search, cursor pagination	Free
GET /v1/trials/{nct_id}	Complete trial detail with outcomes, locations, references	Free
GET /v1/trials/nearby	Geographic radius search by lat/lon, distance-sorted	Free
GET /v1/stats	Aggregate statistics by phase, status, sponsor, study type	Free
GET /v1/conditions	Medical condition autocomplete browser	Free
GET /v1/health	Health check, no auth required	Free
GET /v1/trials/{nct_id}/eligibility	Structured eligibility criteria parsing	Pro
GET /v1/alerts	List active webhook alerts	Pro
POST /v1/alerts	Create a webhook alert for new trials	Pro
DELETE /v1/alerts/{alert_id}	Delete a webhook alert	Pro

The Hard Parts

Challenge 1: Parsing Free-Text Eligibility Criteria

This was the hardest technical problem. ClinicalTrials.gov stores eligibility criteria as free text - often a single paragraph or bulleted list with no structure at all:

"Inclusion Criteria: Histologically confirmed triple-negative breast cancer. Age >= 18 years. ECOG performance status 0 or 1. Adequate hematologic and end-organ function. No prior systemic therapy for metastatic breast cancer. Exclusion Criteria: Prior immunotherapy for breast cancer. Active autoimmune disease requiring systemic treatment. Untreated or symptomatic CNS metastases. Pregnant or breastfeeding."

I needed to parse this into structured, machine-readable criteria objects that a patient-matching algorithm could actually use:

{
  "inclusion_criteria": [
    {"category": "Age", "text": "Age >= 18 years", "criterion": "18 years and older"},
    {"category": "Condition", "text": "Histologically confirmed triple-negative breast cancer", "criterion": "Triple-negative breast cancer confirmed by histology"},
    {"category": "Performance Status", "text": "ECOG performance status 0 or 1", "criterion": "ECOG 0-1"}
  ],
  "exclusion_criteria": [
    {"category": "Prior Treatment", "text": "Prior immunotherapy for breast cancer", "criterion": "No prior checkpoint inhibitor therapy"}
  ]
}

My approach: a heuristic NLP pipeline. First, split the raw text into candidate criteria using regex patterns that match bullet points, numbered lists, line breaks, and sentence boundaries. Then classify each candidate into one of 8 categories (Age, Gender, Condition, Lab Values, Prior Treatment, Performance Status, Organ Function, Other) using keyword matching and rule-based logic. Finally, generate a normalized concise form.

Accuracy is about 80-85%. The remaining 15-20% get category "Other" with raw text preserved. A proper ML model would do better, but I wanted to ship v1 and iterate based on feedback. The structured parsing is on the Pro tier ($49/mo) because it's the core value-add that justifies a paid plan.

Challenge 2: Geographic Search Without a Geocoding Budget

ClinicalTrials.gov lists facility addresses (name, city, state, country) but doesn't provide lat/lon coordinates. To build a geographic radius search, I needed to geocode every facility.

The problem: there are ~500,000 unique facility addresses in the database. Commercial geocoding APIs charge per-1,000 lookups. Free geocoding APIs have strict rate limits (~1 request/second).

My approach: a pre-built lookup table. I ran a Python script over 3 days that geocoded all addresses against a free geocoding API with request throttling. The resulting table maps facility addresses to lat/lon and is loaded into the worker's module-level memory. When you query /v1/trials/nearby, the worker:

Searches ClinicalTrials.gov for trials matching your filters
Looks up each facility's coordinates from the in-memory table
Calculates Haversine distance from your search center
Sorts by distance and returns the results

The table is ~20MB in memory but only contains facilities with active trials. Response time for a nearby search is 400-600ms including the upstream API call and distance calculations. Not instantaneous, but way faster than you'd get geocoding on-the-fly.

Challenge 3: Pricing - Free Tier That's Actually Useful vs. Revenue

The eternal indie dev dilemma. How do you make the free tier useful enough to attract users but restrictive enough to drive conversions?

My approach: give away the data access, charge for the value-add processing.

The free tier includes 7 of 10 endpoints. You can search trials, get details, do geographic searches, browse conditions, pull aggregate stats - everything you need to build a real prototype. 100 requests/day, 3 saved webhook alerts. No credit card, no expiry. The free tier should deliver the "aha moment": "holy crap, I just queried 480K trials in one API call."

The Pro tier ($49/mo) unlocks the features that save real engineering time: structured eligibility parsing (instead of you building a regex parser) and expanded webhook alerts (25 instead of 3, with 6-hour check frequency instead of daily).

Ultra ($199/mo) for companies where clinical trial data is mission-critical. Higher request limits, unlimited alerts, priority support, dedicated SLA.

The conversion hypothesis: free tier users hit the 100 req/day limit or need eligibility parsing, and $49/mo is cheaper than one hour of developer time.

What I'd Do Differently

Geocoding strategy. Spending 3 days rate-limiting against a free geocoding API was dumb. I should have paid $50 for a commercial geocoding service and been done in 2 hours. The "I'll save money by doing it free" instinct is strong in indie devs, but your time is worth more.
API design - separate eligibility endpoint vs. inline. I chose a separate endpoint (/v1/trials/{nct_id}/eligibility) because parsing adds ~200ms of processing, and free tier users shouldn't pay the latency cost for a feature they can't access. In retrospect, returning parsed eligibility inline in the trial detail endpoint would be cleaner. Developers expect one request, not two. I may merge these in v2.

The Numbers (So Far)

Just launched. Real numbers coming soon.

Metric	Value
Subscribers	0 (day 1)
API Calls Served	0 (day 1)
Revenue (MRR)	$0 (day 1)
Uptime	99.9% (target)
Avg Response	350-500ms
Infrastructure Cost	$0 (CF Workers free tier)

I'll update this with real numbers in 30 days.

Try It

https://rapidapi.com/capifactory-capifactory-default/api/clinical-trials-api - free tier, no credit card. Takes 30 seconds to get an API key and make your first call.

If you're building a healthtech product and need clinical trial data, I'd love to hear what endpoints would make this genuinely useful for you. I ship fast - if you need something that doesn't exist yet, tell me and I'll probably have it live within 48 hours.

[Boost]

Rahul Ban — Sun, 24 May 2026 15:58:37 +0000

Rahul Ban

May 24

How to Build a Clinical Trial Search App in 5 Minutes - Clinical Trials API Tutorial

#programming #tutorial #freeapi #healthcare

Comments

6 min read

How to Build a Clinical Trial Search App in 5 Minutes - Clinical Trials API Tutorial

Rahul Ban — Sun, 24 May 2026 15:55:13 +0000

What We're Building

In the next 5 minutes, you'll build a simple web app that lets users search for clinical trials by condition and phase, display results in cards, and paginate through results. Clinical Trials API is a REST API that wraps ClinicalTrials.gov into a developer-friendly interface. It gives you structured eligibility criteria (parsed into categories like Age, Gender, Condition, Lab Values -- no regex needed), geographic radius search by lat/lon, HTTP webhook alerts for new trials, cursor-based pagination, and aggregate statistics. Free tier available with no credit card. 480,000+ trials across 220+ countries, updated daily from the FDA. All powered by one API. You'll need basic HTML/JavaScript knowledge and a free RapidAPI account.

Step 1: Get Your API Key (30 Seconds)

Go to https://rapidapi.com/capifactory-capifactory-default/api/clinical-trials-api
Click "Subscribe" on the Free plan (no credit card required)
Copy your X-RapidAPI-Key from the dashboard

That's it. You're ready to make API calls.

Step 2: Make Your First API Call

Open your terminal and run this curl command (replace YOUR_API_KEY):

curl --request GET \
  --url 'https://clinical-trials-api.p.rapidapi.com/v1/trials/search?query=breast+cancer&phase=Phase+2&status=Recruiting&limit=3' \
  --header 'X-RapidAPI-Key: YOUR_API_KEY'

You should see something like this:

{
  "success": true,
  "data": [
    {
      "nct_id": "NCT04589845",
      "title": "Atezolizumab and Chemotherapy for Triple-Negative Breast Cancer",
      "brief_summary": "This phase II trial studies how well atezolizumab works with chemotherapy...",
      "condition": "Breast Cancer",
      "phase": "Phase 2",
      "status": "Recruiting",
      "enrollment_count": 280,
      "last_updated": "2026-05-15",
      "locations": [
        {
          "facility": "Dana-Farber Cancer Institute",
          "city": "Boston",
          "state": "MA",
          "country": "United States"
        }
      ]
    }
  ],
  "pagination": {
    "total": 847,
    "limit": 3,
    "next_cursor": "eyJvZmZzZXQiOjN9",
    "has_more": true
  }
}

That's 847 matching trials, returned in clean JSON with built-in pagination. No scraping, no parsing, no pipeline maintenance.

Step 3: Build the Trial Search App

Create a single HTML file (index.html) and paste this code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Clinical Trial Search</title>
    <style>
        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 800px; margin: 40px auto; padding: 0 20px; background: #f5f5f5; }
        h1 { color: #1a1a2e; }
        .search-box { display: flex; gap: 10px; margin-bottom: 20px; flex-wrap: wrap; }
        input, select, button { padding: 10px 15px; border: 1px solid #ddd; border-radius: 6px; font-size: 14px; }
        input { flex: 1; min-width: 200px; }
        button { background: #1a56db; color: white; border: none; cursor: pointer; font-weight: 600; }
        button:hover { background: #1647b8; }
        .trial-card { background: white; border-radius: 8px; padding: 20px; margin-bottom: 15px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
        .trial-card h3 { margin: 0 0 8px 0; color: #1a1a2e; font-size: 16px; }
        .trial-meta { display: flex; gap: 15px; font-size: 13px; color: #666; margin-bottom: 8px; flex-wrap: wrap; }
        .badge { padding: 2px 8px; border-radius: 12px; font-size: 12px; font-weight: 600; }
        .badge-recruiting { background: #d4edda; color: #155724; }
        .badge-phase { background: #cce5ff; color: #004085; }
        .summary { font-size: 14px; color: #444; line-height: 1.5; }
        .pagination { display: flex; gap: 10px; align-items: center; margin-top: 20px; justify-content: center; }
        .loading { text-align: center; padding: 40px; color: #666; }
        .error { text-align: center; padding: 20px; color: #dc3545; background: #f8d7da; border-radius: 8px; }
        .nct { color: #1a56db; font-family: monospace; font-size: 14px; }
        .location { font-size: 12px; color: #888; margin-top: 6px; }
    </style>
</head>
<body>
    <h1>Clinical Trial Search</h1>
    <p style="color: #666; margin-bottom: 20px;">Powered by <a href="https://rapidapi.com/capifactory-capifactory-default/api/clinical-trials-api">Clinical Trials API</a> -- 480K+ FDA trials, free tier, no credit card.</p>

    <div class="search-box">
        <input type="text" id="query" placeholder="Search condition or keyword (e.g., breast cancer)" value="breast cancer">
        <select id="phase">
            <option value="">All Phases</option>
            <option value="Phase 1">Phase 1</option>
            <option value="Phase 2" selected>Phase 2</option>
            <option value="Phase 3">Phase 3</option>
            <option value="Phase 4">Phase 4</option>
        </select>
        <select id="status">
            <option value="">All Statuses</option>
            <option value="Recruiting" selected>Recruiting</option>
            <option value="Not yet recruiting">Not Yet Recruiting</option>
            <option value="Active not recruiting">Active, Not Recruiting</option>
            <option value="Completed">Completed</option>
        </select>
        <button onclick="searchTrials()">Search</button>
    </div>

    <div id="results"></div>

    <script>
        const API_KEY = 'YOUR_RAPIDAPI_KEY'; // Replace with your key
        const BASE_URL = 'https://clinical-trials-api.p.rapidapi.com';

        let currentCursor = null;
        let currentQuery = null;

        async function searchTrials(cursor = null) {
            const query = document.getElementById('query').value;
            const phase = document.getElementById('phase').value;
            const status = document.getElementById('status').value;

            const params = new URLSearchParams({ query, limit: '5' });
            if (phase) params.append('phase', phase);
            if (status) params.append('status', status);
            if (cursor) params.append('cursor', cursor);

            const resultsDiv = document.getElementById('results');
            resultsDiv.innerHTML = '<div class="loading">Searching 480K+ clinical trials...</div>';

            try {
                const r = await fetch(`${BASE_URL}/v1/trials/search?${params}`, {
                    headers: { 'X-RapidAPI-Key': API_KEY }
                });

                if (r.status === 401) {
                    resultsDiv.innerHTML = '<div class="error">Invalid API key. Get your free key at <a href="https://rapidapi.com/capifactory-capifactory-default/api/clinical-trials-api">rapidapi.com/clinical-trials-api</a></div>';
                    return;
                }

                if (!r.ok) {
                    resultsDiv.innerHTML = `<div class="error">API error: HTTP ${r.status}</div>`;
                    return;
                }

                const body = await r.json();
                if (!body.success) {
                    resultsDiv.innerHTML = `<div class="error">${body.error?.message || 'Unknown error'}</div>`;
                    return;
                }

                currentCursor = cursor;
                currentQuery = { query, phase, status };
                renderResults(body);

            } catch (e) {
                resultsDiv.innerHTML = `<div class="error">Network error: ${e.message}</div>`;
            }
        }

        function renderResults(body) {
            const resultsDiv = document.getElementById('results');
            const pagination = body.pagination;

            let html = `<p style="color: #666; margin-bottom: 15px;">Found <strong>${pagination.total.toLocaleString()}</strong> trials. Showing ${(currentCursor ? 'next page' : 'first')} ${body.data.length} results.</p>`;

            body.data.forEach(trial => {
                const loc = trial.locations && trial.locations[0] ? `${trial.locations[0].facility}, ${trial.locations[0].city}, ${trial.locations[0].state}` : '';
                html += `
                    <div class="trial-card">
                        <h3>${trial.title}</h3>
                        <div class="trial-meta">
                            <span class="nct">${trial.nct_id}</span>
                            <span class="badge badge-phase">${trial.phase}</span>
                            <span class="badge badge-recruiting">${trial.status}</span>
                            ${trial.enrollment_count ? `<span>${trial.enrollment_count} participants</span>` : ''}
                        </div>
                        <p class="summary">${(trial.brief_summary || '').substring(0, 200)}${(trial.brief_summary || '').length > 200 ? '...' : ''}</p>
                        ${loc ? `<p class="location">${loc}</p>` : ''}
                    </div>
                `;
            });

            html += '<div class="pagination">';

            if (currentCursor) {
                html += `<button onclick="searchTrials(null)">First Page</button>`;
            }

            if (pagination.has_more) {
                html += `<button onclick="loadNextPage('${pagination.next_cursor}')">Next Page (${pagination.total - (currentCursor ? parseInt(currentCursor.match(/\d+/)?.[0] || 0) : body.data.length)} remaining)</button>`;
            } else if (body.data.length > 0) {
                html += '<span style="color: #666;">All results loaded.</span>';
            }

            html += '</div>';
            resultsDiv.innerHTML = html;
        }

        function loadNextPage(cursor) {
            document.getElementById('query').value = currentQuery.query;
            document.getElementById('phase').value = currentQuery.phase;
            document.getElementById('status').value = currentQuery.status;
            searchTrials(cursor);
        }

        // Search on load
        searchTrials();
    </script>
</body>
</html>

Step 4: Run It

Replace YOUR_RAPIDAPI_KEY on line ~70 with your actual API key
Open index.html in your browser (just double-click the file)
You have a working clinical trial search app

Try searching for "Alzheimer", "diabetes", or leave the default "breast cancer" -- you'll see real FDA trial data appear in under a second.

What's Next?

Add the geographic radius search endpoint (/v1/trials/nearby) to build a "trials near me" feature with HTML5 geolocation
Add structured eligibility display by calling /v1/trials/{nct_id}/eligibility when a user clicks a trial card (Pro tier: $19/mo)
Set up a webhook alert via POST /v1/alerts to get notified when new trials match your users' saved search criteria
Deploy to Vercel, Netlify, or GitHub Pages for a live demo
Style it with Tailwind CSS for a professional look

The API

Free tier: 100 requests/day, basic search, nearby search, stats, conditions browser, 3 saved alerts
Pro: $19/mo -- 10,000 requests, structured eligibility parsing, 25 webhook alerts, email support
Ultra: $49/mo -- 50,000 requests, unlimited alerts, priority support
Docs: https://rapidapi.com/capifactory-capifactory-default/api/clinical-trials-api/docs

Subscribe on RapidAPI - free tier, no credit card required.

If you build something with this API, tag me - I'd love to see what you create. Drop questions in the comments and I'll answer them.