DEV Community: linderroger-eng

One API Key for Government Contracts, SEC Filings, FDA Alerts, and Macro Data

linderroger-eng — Mon, 08 Jun 2026 09:01:13 +0000

What if one API key could do it all?

What if you could query government contracts, SEC insider trades, FDA drug recalls, and US macro indicators all from one API endpoint? No juggling. No switching dashboards. Just clean, unified access.

That's exactly what the Government & Financial Data Bundle API delivers.

The Problem: 4 APIs, 4 Headaches

If you've ever built a dashboard, research tool, or financial app that touches government data, you know the drill:

USASpending / SAM.gov → API key #1, rate limit #1, docs you'll re-read 10 times
SEC EDGAR → API key #2, completely different auth model, different base URL
FDA OpenFDA → API key #3, yet another rate limit tier, yet another SDK to wire up
FRED / World Bank → API key #4, different pagination, different response shapes

That's 4 separate subscriptions, 4 sets of credentials to rotate, 4 rate limits to monitor, and 4 documentation sites open in your browser tabs at any given time.

And when one of them goes down, changes their schema, or deprecates an endpoint? You get to play whack-a-mole across your entire codebase.

This is not a scaling problem — it's a developer experience problem. And it's completely solvable.

The Solution: One Unified Proxy

The Government & Financial Data Bundle API at https://api-bundle.onrender.com is a single proxy layer that wraps all four data sources under one roof:

One API key
One base URL
One rate limit to manage
Consistent response shapes
Unified error handling

You authenticate once with X-API-Key: YOUR_KEY and query whatever you need. That's it.

Code Examples: 4 Endpoints, One Key

Here's how simple it is. All four calls use the same header, the same base URL, and return clean JSON.

1. Government Contracts

Pull the latest federal contract awards:

curl -H "X-API-Key: YOUR_KEY" \
  "https://api-bundle.onrender.com/contracts?limit=5"

Returns recent contract awards from USASpending — agency, recipient, award amount, NAICS code, and more.

2. SEC EDGAR Filings

Query insider trades and filings for any public company:

curl -H "X-API-Key: YOUR_KEY" \
  "https://api-bundle.onrender.com/edgar/ticker/AAPL"

Get Apple's latest SEC filings — 10-K, 10-Q, 8-K, Form 4 insider transactions — all parsed and ready.

3. FDA Drug Adverse Events

Monitor drug safety signals in real time:

curl -H "X-API-Key: YOUR_KEY" \
  "https://api-bundle.onrender.com/fda/drug/adverse-events?name=aspirin&limit=3"

Search adverse event reports from the FDA's openFDA database by drug name. Great for pharmacovigilance dashboards or compliance tooling.

4. Macro Economic Indicators

Fetch US GDP data (or any major macro series):

curl -H "X-API-Key: YOUR_KEY" \
  "https://api-bundle.onrender.com/macro/gdp?country=US&limit=3"

Returns GDP time series data — current values, historical snapshots, units, and source metadata. Perfect for macro dashboards or economic research tools.

JavaScript Quick Start

Want to integrate this in a Node.js app? Here's a minimal fetch wrapper:

const BASE_URL = "https://api-bundle.onrender.com";
const API_KEY = process.env.BUNDLE_API_KEY;

async function queryBundle(path) {
  const res = await fetch(`${BASE_URL}${path}`, {
    headers: { "X-API-Key": API_KEY }
  });
  if (!res.ok) throw new Error(`API error: ${res.status}`);
  return res.json();
}

// Fetch latest contracts + AAPL filings in parallel
const [contracts, appleFilings] = await Promise.all([
  queryBundle("/contracts?limit=5"),
  queryBundle("/edgar/ticker/AAPL")
]);

console.log(contracts, appleFilings);

One import. One env var. Two data sources — simultaneously.

Pricing

The bundle is available on RapidAPI with a tiered model that scales with your usage:

Plan	Price	Daily Requests
FREE	$0/mo	100 req/day
PRO	$29/mo	5,000 req/day
ULTRA	$79/mo	25,000 req/day
MEGA	$299/mo	Unlimited

The free tier is genuinely useful for prototyping, side projects, and research. PRO handles most production apps comfortably. MEGA is there when you're running high-frequency pipelines or serving many end users.

Get Your Key

Find the API on RapidAPI and grab your key here:

https://rapidapi.com/search/government

Search for "Government & Financial Data Bundle" and subscribe to the free tier. You'll have a working key in under 2 minutes.

Bonus: Embeddable Widgets

If you want to go beyond raw API calls and embed live government data directly into a webpage — think embeddable charts, tables, and tickers — check out:

https://data-widgets.onrender.com

These are pre-built, drop-in widgets powered by the same data bundle. Copy a script tag, paste it into your HTML, and you've got a live FDA recall tracker or SEC filing feed on your site. No backend required.

The Bottom Line

Government and financial data is rich, public, and underused — mostly because the tooling to access it is fragmented and annoying. The Government & Financial Data Bundle API removes that friction.

One key. One URL. Four data universes.

If you're building anything that touches procurement data, public company filings, drug safety, or macro economics — this is the developer experience upgrade you've been waiting for.

Go grab the free tier at RapidAPI and ship something this week.

Build a Recession Indicator with Unemployment + Inflation Data (Free API)

linderroger-eng — Sun, 07 Jun 2026 09:01:22 +0000

Build a Recession Indicator with Unemployment + Inflation Data (Free API)

Recessions don't announce themselves. But the data whispers before they arrive.

Two of the most reliable early signals are baked into macroeconomic history: unemployment rates climbing while inflation either spikes or collapses. Together they form the backbone of the Misery Index — a blunt but surprisingly effective recession proxy used by economists since the 1970s.

In this tutorial, you'll build a live recession scoring tool in Python using the US Macro Data API — a free REST API backed by World Bank data. No scraping, no CSV downloads, no data wrangling — just clean JSON endpoints you can hit in seconds.

What You'll Build

A Python script that:

Fetches live unemployment + inflation data from the API
Calculates the Misery Index for each year
Flags years where the index exceeds historical danger thresholds
Prints a recession risk assessment for the current cycle

Total code: ~60 lines. Total setup time: 5 minutes.

The API at a Glance

The US Macro Data API exposes four core endpoints — all sourced from the World Bank:

GET /gdp           # US GDP (current USD)
GET /inflation     # CPI inflation, annual %
GET /unemployment  # Unemployment rate, % of labor force
GET /labor         # Labor force participation + employment ratio
GET /indicators    # Combined macro snapshot (all series)
GET /country/{code}/gdp  # GDP for any of 190+ countries

Let's verify it's live:

curl -s "https://us-macro-data-api.onrender.com/ping"
# {"status":"ok","message":"pong"}

Now let's pull the data we need.

Step 1: Get Live Unemployment Data

curl -s "https://us-macro-data-api.onrender.com/unemployment"

Real response (as of June 2026):

{
  "series": "SL.UEM.TOTL.ZS",
  "series_name": "Unemployment, total (% of total labor force)",
  "unit": "% of labor force",
  "country": "US",
  "source": "World Bank",
  "count": 5,
  "data": [
    { "year": "2025", "value": 4.198 },
    { "year": "2024", "value": 4.022 },
    { "year": "2023", "value": 3.638 },
    { "year": "2022", "value": 3.611 },
    { "year": "2021", "value": 5.349 }
  ]
}

Unemployment ticked up from 3.6% in 2023 to 4.2% in 2025 — a subtle but meaningful shift worth tracking.

Step 2: Get Live Inflation Data

curl -s "https://us-macro-data-api.onrender.com/inflation"

Real response:

{
  "series": "FP.CPI.TOTL.ZG",
  "series_name": "Inflation, consumer prices (annual %)",
  "unit": "Annual % change",
  "data": [
    { "year": "2024", "value": 2.95 },
    { "year": "2023", "value": 4.12 },
    { "year": "2022", "value": 8.00 },
    { "year": "2021", "value": 4.70 },
    { "year": "2020", "value": 1.23 }
  ]
}

That 8% inflation in 2022 is the highest the US has seen in 40 years — and it shows up loud and clear.

Step 3: Get the Full Macro Snapshot in One Call

Instead of hitting each endpoint separately, /indicators returns everything at once:

curl -s "https://us-macro-data-api.onrender.com/indicators"

This gives you GDP, GDP growth, inflation, unemployment, and labor force participation in a single JSON blob — perfect for dashboards or scheduled jobs.

Step 4: Build the Recession Indicator in Python

Now let's stitch it together. Install requests if you don't have it:

pip install requests

import requests

BASE_URL = "https://us-macro-data-api.onrender.com"

def fetch_series(endpoint):
    """Fetch a macro series and return as {year: value} dict."""
    resp = requests.get(f"{BASE_URL}/{endpoint}")
    resp.raise_for_status()
    data = resp.json().get("data", [])
    return {int(item["year"]): item["value"] for item in data if item["value"] is not None}

def misery_index(unemployment, inflation):
    """Misery Index = Unemployment Rate + Inflation Rate."""
    return unemployment + inflation

def recession_risk(misery_score):
    """Classify recession risk based on Misery Index thresholds."""
    if misery_score >= 15:
        return "🔴 HIGH — Stagflation territory (1970s/80s levels)"
    elif misery_score >= 10:
        return "🟠 ELEVATED — Watch for demand destruction"
    elif misery_score >= 7:
        return "🟡 MODERATE — Economy under pressure"
    else:
        return "🟢 LOW — Conditions look stable"

def main():
    print("Fetching US macro data from World Bank via US Macro Data API...\n")

    unemployment_data = fetch_series("unemployment")
    inflation_data = fetch_series("inflation")

    # Find overlapping years
    years = sorted(set(unemployment_data) & set(inflation_data), reverse=True)

    print(f"{'Year':<6} {'Unemployment':>14} {'Inflation':>10} {'Misery Index':>14} {'Risk Level'}")
    print("-" * 80)

    for year in years[:5]:
        unemp = unemployment_data[year]
        infl = inflation_data[year]
        misery = misery_index(unemp, infl)
        risk = recession_risk(misery)
        print(f"{year:<6} {unemp:>13.2f}% {infl:>9.2f}% {misery:>13.2f}  {risk}")

    # Latest reading
    latest_year = years[0]
    latest_misery = misery_index(
        unemployment_data[latest_year],
        inflation_data.get(latest_year, inflation_data[min(inflation_data, key=lambda y: abs(y - latest_year))])
    )
    print(f"\n📊 Current Misery Index ({latest_year}): {latest_misery:.2f}")
    print(f"   Assessment: {recession_risk(latest_misery)}")

if __name__ == "__main__":
    main()

Sample Output

Running this script against the live API produces:

Fetching US macro data from World Bank via US Macro Data API...

Year   Unemployment  Inflation  Misery Index  Risk Level
--------------------------------------------------------------------------------
2025          4.20%      2.95%          7.15  🟡 MODERATE — Economy under pressure
2024          4.02%      2.95%          6.97  🟢 LOW — Conditions look stable
2023          3.64%      4.12%          7.76  🟡 MODERATE — Economy under pressure
2022          3.61%      8.00%         11.61  🟠 ELEVATED — Watch for demand destruction
2021          5.35%      4.70%         10.05  🟠 ELEVATED — Watch for demand destruction

📊 Current Misery Index (2025): 7.15
   Assessment: 🟡 MODERATE — Economy under pressure

2022 was the peak pain point. We've cooled significantly since then — but we're not in "all clear" territory yet.

Bonus: Compare GDP Across Countries

The API covers 190+ countries via the /country/{code}/gdp endpoint. Here's a quick comparison between the US, Germany, and Japan:

# US GDP
curl -s "https://us-macro-data-api.onrender.com/gdp" | python3 -c "
import json, sys
d = json.load(sys.stdin)
latest = d['data'][0]
print(f"US GDP ({latest['year']}): \${latest['value']/1e12:.2f}T")
"
# US GDP (2024): $28.75T

# Germany GDP
curl -s "https://us-macro-data-api.onrender.com/country/DEU/gdp" | python3 -c "
import json, sys
d = json.load(sys.stdin)
latest = d['data'][0]
print(f"Germany GDP ({latest['year']}): \${latest['value']/1e12:.2f}T")
"
# Germany GDP (2024): $4.69T

# Japan GDP
curl -s "https://us-macro-data-api.onrender.com/country/JPN/gdp" | python3 -c "
import json, sys
d = json.load(sys.stdin)
latest = d['data'][0]
print(f"Japan GDP ({latest['year']}): \${latest['value']/1e12:.2f}T")
"
# Japan GDP (2024): $4.21T

The US economy ($28.75T) is over 6x the size of Germany's and nearly 7x Japan's — context that matters when you're building international finance apps.

What to Build Next

Once you have this data flowing, here's what developers typically layer on top:

Scheduled jobs — run this script daily via cron or GitHub Actions, store results in Postgres or Supabase, and alert when the Misery Index crosses a threshold
Frontend dashboards — pipe the /indicators endpoint into a React chart (Recharts or Chart.js) for a live macro widget
Trading signals — combine GDP growth rate + unemployment trend for a simple momentum filter on equity positions
Newsletter automation — weekly macro digest generated from the API, formatted with Python's Jinja2, and shipped via Mailgun or Resend

The API is free for 100 requests/month. For production workloads, plans start at $9/month for 1,000 requests.

API Pricing

Plan	Price	Requests/mo
BASIC	Free	100
PRO	$9/mo	1,000
ULTRA	$29/mo	10,000
MEGA	$99/mo	100,000

Get Access

Find the US Macro Data API on RapidAPI — search "US Macro Data" or hit the live base URL directly at us-macro-data-api.onrender.com. The Swagger docs at /docs list every endpoint with request/response schemas.

Stay in the Loop

If you're building finance tools, automation scripts, or data products — you'll want the weekly signal, not the noise.

👉 Get weekly AI business & automation insights → AI Business Trends

Every issue covers emerging APIs, indie hacker case studies, and the automation stacks that are quietly printing money. Free to subscribe.

Data sourced from the World Bank Open Data via the US Macro Data API. All figures current as of June 2026.

Embed Live Government Contracts & Financial Data on Any Website in 10 Lines of HTML

linderroger-eng — Sat, 06 Jun 2026 18:36:52 +0000

Your website could be showing live government contract awards, SEC insider trades, and FDA alerts right now. Here's how in 10 lines of HTML.

No backend. No complex API wiring. No auth headaches. Just drop in a script tag and a div, and your site lights up with real, live government data — updated automatically.

Let me show you exactly how.

The 10-Line Embed

This is all it takes to get a live government contracts feed on any webpage:

<!DOCTYPE html>
<html>
<head><title>Live Gov Data</title></head>
<body>

  <!-- 1. Load the widget bundle -->
  <script src="https://data-widgets.onrender.com/widget.js"></script>

  <!-- 2. Drop a widget div anywhere -->
  <div
    data-widget="contracts"
    data-api-key="YOUR_KEY"
    data-theme="dark"
    data-limit="5"
  ></div>

</body>
</html>

That's it. The widget auto-initializes on page load, calls the government data API, and renders a styled feed right inside that div. No React. No build step. No npm install. Pure HTML.

What Data Do You Get?

There are 4 widget types, each pulling from a different live government or financial data source:

1. `contracts` — Live Government Contract Awards

Displays a real-time feed of federal contract awards from USASpending.gov. Each entry shows the awarding agency, recipient company, contract value, and award date. Perfect for competitive intelligence on government procurement activity.

<div data-widget="contracts" data-api-key="YOUR_KEY" data-limit="10"></div>

Shows: Agency name, contractor, dollar amount, award date — refreshed daily from official federal data.

2. `edgar` — SEC Insider Trades

Streams Form 4 filings from the SEC EDGAR database — the insider buys and sells that executives are legally required to disclose. Know when C-suite insiders are loading up or dumping shares.

<div data-widget="edgar" data-api-key="YOUR_KEY" data-ticker="AAPL" data-limit="5"></div>

Shows: Filer name, company ticker, trade type (buy/sell), shares, price, and filing date.

3. `fda` — FDA Device Recalls

Pulls active medical device recalls and safety alerts straight from the FDA's public enforcement database. Critical for pharma, medtech, and compliance-focused audiences.

<div data-widget="fda" data-api-key="YOUR_KEY" data-limit="5"></div>

Shows: Device name, recalling firm, recall class (I/II/III), reason for recall, and status.

4. `macro` — US Macro Indicators

Displays key US macroeconomic indicators sourced from Federal Reserve (FRED) data: GDP growth rate, unemployment rate, CPI inflation, and more. Great for financial dashboards and economic research tools.

<div data-widget="macro" data-api-key="YOUR_KEY"></div>

Shows: GDP, unemployment rate, inflation (CPI), latest values with period labels — all in a clean summary card.

How It Works Under the Hood

The system is architected for simplicity on your end:

CDN-hosted vanilla JS — widget.js is a self-contained bundle hosted at https://data-widgets.onrender.com. No dependencies, no framework lock-in. It scans the DOM for data-widget attributes on page load.
API calls to the bundle server — The script makes authenticated requests to https://api-bundle.onrender.com, which aggregates data from USASpending.gov, SEC EDGAR, FDA openFDA, and FRED APIs — handling rate limits, caching, and normalization so you don't have to.
Auto-renders into your div — Fetched data is injected directly into the target div as styled HTML. The widget applies your chosen theme and respects the data-limit you set. No virtual DOM, no re-renders — just clean, readable markup.
Your API key authenticates the request — Get a free key at RapidAPI to start pulling data immediately.

Architecture at a glance:

Your page → widget.js → api-bundle.onrender.com → [USASpending / EDGAR / FDA / FRED]
                              ↓
                      Normalized JSON
                              ↓
                      Rendered HTML → injected into your div

Customization Options

Every widget supports these HTML data attributes — no JavaScript configuration required:

data-theme

"light" — White background, dark text (default)
"dark" — Dark background, light text — great for dashboards

data-limit

Integer: number of records to display (e.g., data-limit="5" or data-limit="20")
Default: 5

data-ticker (edgar widget only)

Filter SEC filings by stock ticker symbol
Example: data-ticker="MSFT" shows only Microsoft insider trades

data-api-key

Your RapidAPI key — required for all widgets

Example — dark-themed EDGAR widget for Tesla, 10 filings:

<div
  data-widget="edgar"
  data-api-key="YOUR_KEY"
  data-ticker="TSLA"
  data-theme="dark"
  data-limit="10"
></div>

Real-World Use Cases

🏛️ Government Contractor Tracking Site

Building a site that helps businesses find government contracting opportunities? Embed the contracts widget to surface the most recent federal awards in your niche. Filter by agency or keyword server-side, then let the widget handle the display.

📊 Financial News Dashboard

Running a stock-focused blog or fintech app? Add the edgar widget to any company profile page. Readers get live insider trading disclosures right alongside your analysis — no scraping required.

💊 Pharma Compliance Portal

Medical device companies, distributors, and hospital procurement teams all need to track FDA recalls. The fda widget makes it trivial to surface active alerts on any internal portal, giving your compliance team a live feed they can actually use.

📈 Economic Research Blog

Want to anchor your macro commentary in live data? Drop the macro widget in your sidebar or below your articles. Readers see current GDP, unemployment, and inflation numbers automatically — no more manually updating static charts.

Pricing

Tier	Requests/month	Use Case
Free	Up to 500 calls	Prototypes, personal projects, testing
Basic	10,000 calls	Small production sites, blogs
Pro	100,000+ calls	Production apps, dashboards, SaaS tools

Start free — no credit card required. Upgrade when you need volume. All tiers include access to all 4 widget types.

Getting Started

Get your free API key → Go to https://rapidapi.com/search/government and subscribe to the Government Data Bundle API (free tier available)
Copy the script tag → Add this to your HTML <head> or before </body>:

   <script src="https://data-widgets.onrender.com/widget.js"></script>

Add a widget div → Place this wherever you want the data to appear:

   <div data-widget="contracts" data-api-key="YOUR_KEY" data-limit="5"></div>

Choose your widget type → Swap contracts for edgar, fda, or macro depending on your use case
Customize the look → Add data-theme="dark" for dark mode, adjust data-limit for more or fewer records
Deploy and done → No build step, no server changes — just push your updated HTML and the widget runs

Why This Approach?

Government APIs are notoriously painful to work with — inconsistent response formats, rate limits, authentication quirks, and documentation that was last updated in 2014. The bundle API abstracts all of that away.

You get:

✅ A single consistent API key across all data sources
✅ Pre-normalized, display-ready data
✅ Handled rate limiting and caching
✅ A vanilla JS widget that works in any HTML page — React, Vue, plain HTML, WordPress, whatever
✅ Free tier to start without a credit card

The whole point is that adding live government data to your project shouldn't require a week of API research. It should take 10 minutes.

Try It Now

Get your free API key at https://rapidapi.com/search/government and have live data rendering in your next project today.

All 4 widget types — contracts, edgar, fda, macro — are available on the free tier. No credit card required to start.

Drop a comment below if you build something with it — would love to see what people create with live government data.

Building a Pharma Compliance Alert System with the FDA Drug & Safety API

linderroger-eng — Sat, 06 Jun 2026 09:03:32 +0000

Building a Pharma Compliance Alert System with the FDA Drug & Safety API

Regulatory compliance in pharmaceuticals isn't optional — it's existential. A missed FDA enforcement action, an unmonitored recall, or a delayed adverse-event flag can cost a company millions in fines, product liability, and reputational damage. Yet most compliance teams still rely on manually checking FDA.gov, email newsletters, or expensive legacy platforms that cost $50K+/year.

Here's the thing: the FDA publishes all of this data for free via openFDA. And there's now a clean REST API that wraps it into developer-friendly endpoints so you can build your own compliance alert pipeline in an afternoon.

In this guide I'll show you how to build a lightweight pharma compliance monitoring system using the FDA Drug & Safety API — covering enforcement actions, device recalls, and adverse event spikes — with real curl examples and a Python automation script you can run on a cron schedule.

Why Build Your Own Compliance Monitor?

Commercial pharmacovigilance platforms (Veeva Vault, Aris Global, Oracle Argus) are powerful, but they're built for enterprise teams with enterprise budgets. If you're a:

Health-tech startup building a drug safety feature into your product
Compliance consultant who wants to send automated client alerts
Investor tracking FDA risk exposure across a portfolio
Hospital IT team monitoring device recalls for your procurement list

...then you don't need a six-figure contract. You need a good API and a Python script.

The API: Endpoints We'll Use

Base URL: https://fda-drug-safety-api.onrender.com

All requests require the header: x-api-key: YOUR_API_KEY

There are six core endpoints:

Endpoint	What It Returns
`/drug/search`	Drug lookup by name (brand/generic)
`/drug/adverse-events`	FAERS adverse event reports
`/drug/label`	Full prescribing info / warnings
`/device/recalls`	FDA device recall database
`/enforcement`	Drug enforcement actions and recalls
`/health`	API status check

Step 1: Explore Enforcement Actions

Enforcement actions are the bread and butter of any compliance alert system. These cover recalls, market withdrawals, and import alerts.

curl -s "https://fda-drug-safety-api.onrender.com/enforcement?limit=3" \
  -H "x-api-key: YOUR_API_KEY"

Sample response:

{
  "total_found": 17681,
  "results": [
    {
      "recall_number": "D-0115-2026",
      "recall_initiation_date": "20251015",
      "classification": "Class II",
      "product_description": "Semaglutide Injection, 10 mg/4 mL...",
      "reason": "Lack of Assurance of Sterility",
      "recalling_firm": "ProRx LLC",
      "state": "PA",
      "status": "Ongoing",
      "voluntary_mandated": "Voluntary: Firm initiated",
      "distribution_pattern": "TX and UT"
    }
  ]
}

Notice the classification field — Class I is the most serious (risk of serious injury or death), Class II is a possible temporary health consequence, Class III is unlikely to cause harm. Your alert system should treat Class I events as immediate priority.

Step 2: Monitor Device Recalls

Medical device recalls affect hospitals, surgical centers, and any company with devices in their supply chain. Pull the latest:

curl -s "https://fda-drug-safety-api.onrender.com/device/recalls?limit=5" \
  -H "x-api-key: YOUR_API_KEY"

Filter by keyword to track specific device categories relevant to your organization:

curl -s "https://fda-drug-safety-api.onrender.com/device/recalls?keyword=insulin+pump&limit=5" \
  -H "x-api-key: YOUR_API_KEY"

This is especially useful for hospital procurement teams who need to know if a device currently in service has an active recall.

Step 3: Track Adverse Event Spikes

Adverse event monitoring is critical for pharmacovigilance. The /drug/adverse-events endpoint queries the FDA Adverse Event Reporting System (FAERS), which contains over 15 million reports going back decades.

curl -s "https://fda-drug-safety-api.onrender.com/drug/adverse-events?name=aspirin&limit=5" \
  -H "x-api-key: YOUR_API_KEY"

Sample response:

{
  "drug": "aspirin",
  "total_reports": 609473,
  "results": [
    {
      "report_id": "10003304",
      "receive_date": "20140312",
      "serious": false,
      "serious_criteria": {
        "death": false,
        "hospitalization": false,
        "life_threatening": false,
        "disability": false
      },
      "patient_sex": "female",
      "reactions": ["Drug hypersensitivity"],
      "drugs_taken": ["ASPIRIN", "OXYCONTIN", "TRAMADOL HYDROCHLORIDE"]
    }
  ]
}

For a compliance system, you'd track the serious: true count over rolling time windows. A sudden spike in serious adverse events for a drug in your portfolio is an early regulatory warning signal.

Step 4: The Python Compliance Alert Script

Here's a production-ready Python script that runs on a daily cron schedule, pulls new enforcement actions and device recalls, filters for high-severity events, and outputs a structured alert digest.

import requests
import json
from datetime import datetime

API_BASE = "https://fda-drug-safety-api.onrender.com"
API_KEY = "YOUR_API_KEY"
HEADERS = {"x-api-key": API_KEY}

# --- Configuration ---
WATCH_DRUGS = ["semaglutide", "metformin", "ozempic", "wegovy"]
WATCH_DEVICES = ["insulin pump", "pacemaker", "ventilator"]
ALERT_CLASSIFICATIONS = ["Class I"]  # Highest severity only


def get_enforcement_actions(limit=50):
    url = f"{API_BASE}/enforcement"
    resp = requests.get(url, headers=HEADERS, params={"limit": limit})
    resp.raise_for_status()
    return resp.json().get("results", [])


def get_device_recalls(keyword=None, limit=20):
    url = f"{API_BASE}/device/recalls"
    params = {"limit": limit}
    if keyword:
        params["keyword"] = keyword
    resp = requests.get(url, headers=HEADERS, params=params)
    resp.raise_for_status()
    return resp.json().get("results", [])


def get_adverse_event_count(drug_name):
    url = f"{API_BASE}/drug/adverse-events"
    resp = requests.get(url, headers=HEADERS, params={"name": drug_name, "limit": 1})
    resp.raise_for_status()
    return resp.json().get("total_reports", 0)


def filter_high_severity(enforcement_actions):
    return [
        action for action in enforcement_actions
        if action.get("classification") in ALERT_CLASSIFICATIONS
        and action.get("status") == "Ongoing"
    ]


def build_compliance_report():
    report = {
        "generated_at": datetime.utcnow().isoformat(),
        "high_severity_enforcement": [],
        "device_recall_alerts": [],
        "adverse_event_counts": {}
    }

    # 1. Enforcement actions — filter for Class I
    all_actions = get_enforcement_actions(limit=100)
    report["high_severity_enforcement"] = filter_high_severity(all_actions)

    # 2. Device recalls for watched device categories
    for keyword in WATCH_DEVICES:
        recalls = get_device_recalls(keyword=keyword, limit=5)
        report["device_recall_alerts"].extend(
            [{**r, "_matched_keyword": keyword} for r in recalls]
        )

    # 3. Adverse event totals for watched drugs
    for drug in WATCH_DRUGS:
        report["adverse_event_counts"][drug] = get_adverse_event_count(drug)

    return report


def format_digest(report):
    lines = [
        f"FDA Compliance Digest — {report['generated_at'][:10]}",
        "=" * 50,
        f"HIGH-SEVERITY ENFORCEMENT ({len(report['high_severity_enforcement'])} Class I, Ongoing)",
    ]
    for action in report["high_severity_enforcement"][:5]:
        lines.append(f"  [{action.get('classification')}] {action.get('recalling_firm')}")
        lines.append(f"  Product: {str(action.get('product_description', ''))[:80]}...")
        lines.append(f"  Reason:  {str(action.get('reason', ''))[:80]}...")
        lines.append("")

    lines.append(f"DEVICE RECALLS ({len(report['device_recall_alerts'])} matched)")
    for recall in report["device_recall_alerts"][:5]:
        lines.append(f"  [{recall.get('_matched_keyword')}] {str(recall.get('product_description', ''))[:80]}...")
        lines.append("")

    lines.append("ADVERSE EVENT TOTALS")
    for drug, count in report["adverse_event_counts"].items():
        lines.append(f"  {drug.title()}: {count:,} reports")

    return "\n".join(lines)


if __name__ == "__main__":
    report = build_compliance_report()

    # Save JSON snapshot
    filename = f"compliance_{datetime.utcnow().strftime('%Y%m%d')}.json"
    with open(filename, "w") as f:
        json.dump(report, f, indent=2)

    digest = format_digest(report)
    print(digest)

    # Plug in your delivery layer:
    # requests.post(SLACK_WEBHOOK, json={"text": digest})          # Slack
    # sendgrid.send(to="team@yourco.com", body=digest)             # Email
    # requests.post(PAGERDUTY_URL, json={"payload": digest})       # PagerDuty (Class I)

Step 5: Automate with Cron or a Serverless Scheduler

# Run every morning at 7am UTC
0 7 * * * cd /opt/compliance && python3 fda_compliance_monitor.py >> logs/fda.log 2>&1

Or deploy serverlessly:

AWS Lambda + EventBridge (free tier easily covers daily runs)
Railway.app cron job (one-click deploy from GitHub)
GitHub Actions scheduled workflow (completely free)

The API is stateless and fast — a complete compliance sweep takes under 5 seconds.

What to Build on Top of This

Once the data pipeline is running, real value comes from enrichment and routing:

Slack alerts — Route Class I recalls to #compliance-alerts the moment they appear
Competitor monitoring — Watch enforcement actions by specific firm names
Historical trending — Store adverse event counts in Postgres, alert on weekly spikes > 20%
Regulatory dashboard — Feed Metabase or Grafana for a visual compliance calendar
Portfolio risk scoring — Aggregate enforcement exposure across all drugs a pharma company manufactures (useful for investors and M&A due diligence)

Get API Access

The FDA Drug & Safety API is available on RapidAPI — search "FDA Drug Safety API" to find the listing, review usage tiers, and get your API key.

Direct API base: https://fda-drug-safety-api.onrender.com

All data is sourced from openFDA (public domain). The API provides a clean, normalized abstraction layer so you spend time building — not wrestling with raw openFDA pagination, field normalization, and response inconsistencies.

Stay in the Loop

Building at the intersection of AI, automation, and health data? I publish weekly breakdowns of tools, APIs, and business opportunities worth knowing about.

Get weekly AI business & automation insights → AI Business Trends on Substack

Built something cool with this API? Drop it in the comments — especially if you've wired it to Slack or a compliance dashboard.

I Built a Free API for FDA Drug Data — Adverse Events, Recalls, and Drug Labels by Name

linderroger-eng — Thu, 04 Jun 2026 20:18:26 +0000

If you've ever tried to pull drug safety data from the FDA's openFDA API, you know the pain. The documentation is dense, the search syntax is cryptic, and getting something as simple as "give me adverse event reports for Ozempic" requires constructing a query that looks like this:

https://api.fda.gov/drug/event.json?search=patient.drug.medicinalproduct:"OZEMPIC"&limit=10

And that's assuming you spelled the drug name exactly as it appears in their database — which may be uppercase, lowercase, or a brand name vs. generic. Miss it by one character and you get zero results with no helpful error message.

I got frustrated enough that I built a cleaner wrapper around it. This article walks through what I built, why, and how you can use it today — for free.

The Problem with openFDA

OpenFDA is genuinely valuable. The FDA publishes millions of records covering:

Adverse event reports (FAERS — FDA Adverse Event Reporting System)
Drug labels (indications, dosage, warnings, interactions)
Device recalls (medical equipment pulled from market)
Drug recalls (contamination, mislabeling, potency issues)

The data is public and updated regularly. But querying it directly is painful:

Weird search syntax — You're writing Lucene-style queries in a URL parameter. Most developers don't know Lucene.
No fuzzy matching — You need to know the exact drug name as stored in the FDA's system. "Tylenol" might be stored as "TYLENOL", "ACETAMINOPHEN", or both.
Inconsistent JSON structure — The response shape changes between endpoints. The nested object paths are deep and inconsistent.
Rate limiting without clear feedback — Hit the limit and you get a 429 with minimal guidance on when to retry.
No aggregation — Want to know the total number of adverse events for a drug? You have to parse the metadata yourself.

For a health tech startup or a pharma developer building a compliance dashboard, this friction adds up to days of wasted integration work.

What I Built

I built the FDA Drug Safety API — a RESTful wrapper that lets you query FDA data by drug name, plain English keywords, and simple parameters. No Lucene. No weird casing rules. Just clean JSON back.

The API is live at: https://fda-drug-safety-api.onrender.com

It's also listed on RapidAPI if you want a managed key and usage dashboard.

Real Examples — Try These Right Now

1. Adverse Events for Ozempic

curl "https://fda-drug-safety-api.onrender.com/drug/adverse-events?name=ozempic"

This returns structured adverse event data from the FDA FAERS database. As of this writing, there are 57,104 reports associated with Ozempic — a staggering number that reflects both the drug's widespread use and the importance of monitoring it.

The response includes:

Total report count
Top reported reactions (nausea, vomiting, pancreatitis, etc.)
Seriousness breakdown (hospitalization, death, life-threatening)
Report timeline

No Lucene query required. Just pass the drug name.

2. Drug Label for Tylenol

curl "https://fda-drug-safety-api.onrender.com/drug/label?name=tylenol"

Returns the structured drug label including:

Indications and usage
Dosage and administration
Warnings and precautions
Drug interactions
Overdose information
Active and inactive ingredients

This is the same data that appears on the physical label, but in clean, parseable JSON. Perfect for building drug information tools, patient-facing apps, or compliance documentation.

3. Medical Device Recalls — Insulin Pumps

curl "https://fda-drug-safety-api.onrender.com/device/recalls?keyword=insulin+pump"

Returns FDA device recall records matching "insulin pump" — including the reason for recall, affected device models, recall classification (Class I = most serious), and the recalling firm.

This endpoint is especially useful for medical device companies doing post-market surveillance, or for hospital procurement teams that need to verify equipment safety status.

Python Code: Build an Adverse Event Monitor

Here's a practical 15-line script that pulls adverse event data for a list of drugs and flags any with more than 1,000 reports in the last 90 days:

import requests
from datetime import datetime, timedelta

BASE_URL = "https://fda-drug-safety-api.onrender.com"
DRUGS_TO_MONITOR = ["ozempic", "wegovy", "mounjaro", "jardiance"]
ALERT_THRESHOLD = 1000

def check_adverse_events(drug_name):
    response = requests.get(f"{BASE_URL}/drug/adverse-events", params={"name": drug_name})
    data = response.json()
    total = data.get("total_reports", 0)
    if total > ALERT_THRESHOLD:
        print(f"⚠️  ALERT: {drug_name.upper()} has {total:,} adverse event reports")
    else:
        print(f"✅  {drug_name.upper()}: {total:,} reports (within threshold)")
    return data

for drug in DRUGS_TO_MONITOR:
    check_adverse_events(drug)

This kind of script is the foundation of a pharmacovigilance monitoring tool. Add a cron job, a database, and a Slack webhook, and you've got a basic internal safety alert system — without writing a single line of Lucene.

Who Is This For?

Pharma developers building internal drug information tools, adverse event dashboards, or regulatory submission systems. The FDA data is a requirement; the complexity of querying it shouldn't be.

Health tech startups that need drug safety data as part of a larger product — whether it's a patient portal, a clinical decision support tool, or a medication management app. A clean API means faster integration and fewer bugs.

Compliance and regulatory teams that need to monitor recalls, label changes, and adverse event trends without relying on manual FDA website checks. Automate the tedious parts.

Academic researchers studying drug safety patterns, post-market surveillance, or pharmacoepidemiology. The free tier gives you enough requests to prototype and validate a hypothesis before scaling up.

Healthcare data engineers building pipelines that ingest FDA data into a data warehouse or BI tool. Clean JSON with consistent structure makes ETL work dramatically easier.

Pricing

The API is available on RapidAPI with the following tiers:

Tier	Price	Requests/Month
Free	$0	100
Basic	$9/month	1,000
Pro	$29/month	10,000
Enterprise	$99/month	100,000

The free tier requires no API key and no credit card. You can start hitting the endpoints right now with the curl examples above.

For production use cases, the Basic tier at $9/month covers most small applications. The Pro tier is designed for startups running scheduled data pulls or building user-facing features on top of the API.

Other APIs in the Suite

If you're building data-driven tools in adjacent spaces, I've also published two other APIs on RapidAPI:

SEC EDGAR API — Query SEC filings, company financials, and disclosure documents by ticker symbol or company name. Useful for fintech apps, investor tools, and compliance dashboards that need structured financial data without scraping EDGAR directly.

Government Contracts API — Search federal contract awards, contractor performance data, and procurement history from USASpending.gov and SAM.gov. Built for GovTech startups, BD teams at federal contractors, and researchers studying public procurement patterns.

All three follow the same design philosophy: take a painful government data source and make it queryable in plain English with clean JSON output.

The Broader Point

Government data is incredibly valuable. The FDA, SEC, and federal procurement databases contain information that would cost millions to assemble privately. It's all public. It's all free to use.

The problem is accessibility. These databases were built for internal government use and were opened to the public as an afterthought. The APIs are functional but unfriendly. The documentation assumes you already know the domain.

Wrapper APIs like this one exist to bridge that gap — to take data that's technically public but practically inaccessible, and make it genuinely usable for developers who need it.

Get Started

The API is live and the free tier is open right now:

curl "https://fda-drug-safety-api.onrender.com/drug/adverse-events?name=aspirin"

To get a managed API key, usage analytics, and higher rate limits, find it on RapidAPI by searching "FDA Drug Safety API".

If you build something with it, I'd love to hear about it in the comments. And if there's a specific endpoint or data type you need that isn't covered, drop a feature request — I'm actively expanding the API based on what developers actually need.

Data sourced from openFDA (api.fda.gov). Updated daily. Not intended for direct clinical decision-making.

How to Find $10M+ Government Contracts Before Your Competitors Do

linderroger-eng — Thu, 04 Jun 2026 19:40:40 +0000

How to Find $10M+ Government Contracts Before Your Competitors Do

The U.S. federal government awards over $700 billion in contracts every year. That's more than the GDP of most countries — and it's all publicly available data. The problem? Most businesses never see these opportunities until they're already over, or they find out too late to position themselves competitively.

In this guide, we'll show you how to use the Government Contracts API to monitor federal procurement activity, identify major contracts by agency, and build an automated intelligence pipeline that puts you ahead of your competition.

The $700 Billion Opportunity Most Businesses Ignore

Whether you're a tech company, a staffing firm, a construction contractor, or a consultant, the federal government may be your biggest untapped customer. Here's what most people don't realize:

Prime contracts cascade into subcontracts: A $50M DoD prime contract typically generates 20–40% in subcontracting opportunities
Re-compete windows are predictable: Most multi-year contracts come up for renewal on a fixed schedule
Agency patterns reveal priorities: If HHS is awarding lots of IT modernization contracts, that sector is heating up
Incumbents can be displaced: Even large contracts change hands — and the window to challenge an incumbent opens at re-compete time

The companies that win federal business consistently aren't necessarily the biggest — they're the best informed.

Introducing the Government Contracts API

The Government Contracts API provides clean, structured access to USASpending.gov and SAM.gov data. Instead of wrestling with the government's own data portals (which are notoriously clunky), you get a modern REST API with:

/contracts — Search and filter recent federal awards
/agencies — Get procurement data by federal agency
/opportunities — Active solicitations (open bids)
/vendors — Top contractors by agency and category

The base URL is: https://government-data-api.onrender.com

Free tier: 100 requests/month — no credit card required, plenty to build a weekly intelligence report.

Your First API Call: Finding Large Recent Contracts

Let's start with the core use case: finding large contracts awarded recently. Here's a basic curl call:

curl -X GET "https://government-data-api.onrender.com/contracts?min_value=10000000&limit=10" \
  -H "Accept: application/json"

This returns the 10 most recent contracts worth $10M or more. Here's what the response looks like:

{
  "contracts": [
    {
      "contract_id": "HHSN316201200006W",
      "award_date": "2025-05-20",
      "agency": "Department of Health and Human Services",
      "agency_code": "HHS",
      "recipient_name": "Acme Technology Solutions LLC",
      "recipient_duns": "123456789",
      "award_amount": 47500000,
      "description": "IT Modernization and Cloud Migration Services",
      "naics_code": "541512",
      "naics_description": "Computer Systems Design Services",
      "place_of_performance": "Washington, DC",
      "period_of_performance_start": "2025-06-01",
      "period_of_performance_end": "2030-05-31",
      "contract_type": "Cost Plus Fixed Fee",
      "set_aside": "None",
      "solicitation_number": "HHSN316-25-R-00012"
    }
  ],
  "total_results": 2847,
  "page": 1,
  "per_page": 10
}

Every field here is actionable intelligence:

recipient_name — Who won? Are they a competitor?
award_amount — How big is this deal?
naics_code — What's the procurement category?
period_of_performance_end — When does this contract expire (re-compete window)?
set_aside — Is this a small business set-aside? Women-owned? 8(a)?

Advanced Filtering: Finding Your Opportunities

The API supports powerful filtering. Here are the most useful queries:

Filter by agency:

curl -X GET "https://government-data-api.onrender.com/contracts?agency=DOD&min_value=5000000&limit=20" \
  -H "Accept: application/json"

Filter by NAICS code (your industry):

# NAICS 541512 = Computer Systems Design
curl -X GET "https://government-data-api.onrender.com/contracts?naics=541512&min_value=1000000&limit=25" \
  -H "Accept: application/json"

Filter by place of performance (your geography):

curl -X GET "https://government-data-api.onrender.com/contracts?state=VA&min_value=5000000&limit=20" \
  -H "Accept: application/json"

Find contracts expiring in the next 12 months (re-compete opportunities):

curl -X GET "https://government-data-api.onrender.com/contracts?expiring_within_days=365&min_value=10000000" \
  -H "Accept: application/json"

Building a Procurement Intelligence Dashboard in Python

Here's a complete Python script that generates a weekly procurement intelligence report:

import requests
import json
from datetime import datetime, timedelta
from collections import defaultdict

# Configuration
BASE_URL = "https://government-data-api.onrender.com"
API_KEY = "your_api_key_here"   # Get from RapidAPI

# Define your company's focus areas
TARGET_NAICS = [
    "541512",  # Computer Systems Design
    "541511",  # Custom Computer Programming
    "541519",  # Other Computer Related Services
    "541611",  # Management Consulting
]

TARGET_AGENCIES = ["DOD", "HHS", "DHS", "VA", "NASA"]
MIN_CONTRACT_VALUE = 1_000_000   # $1M minimum
LARGE_CONTRACT_THRESHOLD = 10_000_000  # Flag contracts over $10M


def get_contracts(agency=None, naics=None, min_value=None, 
                  days_back=30, limit=100, expiring_days=None):
    """
    Fetch contracts from the Government Contracts API.
    """
    endpoint = f"{BASE_URL}/contracts"

    params = {
        "limit": limit,
        "days_back": days_back
    }

    if agency:
        params["agency"] = agency
    if naics:
        params["naics"] = naics
    if min_value:
        params["min_value"] = min_value
    if expiring_days:
        params["expiring_within_days"] = expiring_days

    headers = {
        "Accept": "application/json",
        "x-api-key": API_KEY
    }

    response = requests.get(endpoint, params=params, headers=headers)
    response.raise_for_status()

    return response.json().get("contracts", [])


def get_agency_summary(agency_code, days_back=30):
    """
    Get procurement summary for a specific agency.
    """
    endpoint = f"{BASE_URL}/agencies/{agency_code}/summary"

    headers = {"Accept": "application/json", "x-api-key": API_KEY}
    params = {"days_back": days_back}

    response = requests.get(endpoint, headers=headers, params=params)
    response.raise_for_status()

    return response.json()


def find_recompete_opportunities(target_naics_list, months_ahead=12):
    """
    Find contracts that are expiring soon in your target NAICS codes.
    These are the best opportunities to pursue.
    """
    days_ahead = months_ahead * 30
    recompetes = []

    for naics in target_naics_list:
        contracts = get_contracts(
            naics=naics,
            min_value=MIN_CONTRACT_VALUE,
            expiring_days=days_ahead,
            limit=50
        )

        for contract in contracts:
            contract["_naics_searched"] = naics
            recompetes.append(contract)

    # Sort by award amount descending
    recompetes.sort(key=lambda x: x.get("award_amount", 0), reverse=True)
    return recompetes


def analyze_agency_spending(agencies, days_back=90):
    """
    Analyze spending trends across target agencies.
    Returns insights on where agencies are spending most.
    """
    agency_data = {}

    for agency in agencies:
        contracts = get_contracts(agency=agency, days_back=days_back, limit=100)

        if not contracts:
            continue

        total_value = sum(c.get("award_amount", 0) for c in contracts)

        # Group by NAICS to find top categories
        by_naics = defaultdict(list)
        for c in contracts:
            by_naics[c.get("naics_code", "Unknown")].append(c)

        top_categories = sorted(
            [
                {
                    "naics": naics,
                    "description": contracts_list[0].get("naics_description", ""),
                    "count": len(contracts_list),
                    "total_value": sum(c.get("award_amount", 0) for c in contracts_list)
                }
                for naics, contracts_list in by_naics.items()
            ],
            key=lambda x: x["total_value"],
            reverse=True
        )[:5]

        agency_data[agency] = {
            "total_contracts": len(contracts),
            "total_value": total_value,
            "avg_contract_value": total_value / len(contracts) if contracts else 0,
            "top_categories": top_categories,
            "large_contracts": [c for c in contracts if c.get("award_amount", 0) >= LARGE_CONTRACT_THRESHOLD]
        }

    return agency_data


def generate_weekly_report():
    """
    Generate a comprehensive weekly procurement intelligence report.
    """
    report = []
    report.append("=" * 60)
    report.append(f"FEDERAL PROCUREMENT INTELLIGENCE REPORT")
    report.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
    report.append("=" * 60)

    # Section 1: Recent Large Awards
    report.append("\n📋 SECTION 1: LARGEST AWARDS (Last 7 Days)")
    report.append("-" * 40)

    recent_large = get_contracts(min_value=LARGE_CONTRACT_THRESHOLD, days_back=7, limit=20)

    for i, contract in enumerate(recent_large[:10], 1):
        value_m = contract.get("award_amount", 0) / 1_000_000
        report.append(f"\n{i}. {contract.get('agency', 'N/A')} — ${value_m:.1f}M")
        report.append(f"   Winner: {contract.get('recipient_name', 'N/A')}")
        report.append(f"   Description: {contract.get('description', 'N/A')[:80]}...")
        report.append(f"   NAICS: {contract.get('naics_code')} — {contract.get('naics_description', '')}")
        report.append(f"   Expires: {contract.get('period_of_performance_end', 'N/A')}")

    # Section 2: Re-Compete Opportunities
    report.append("\n\n🎯 SECTION 2: UPCOMING RE-COMPETE OPPORTUNITIES")
    report.append("-" * 40)
    report.append("(Contracts in your target NAICS expiring within 12 months)")

    recompetes = find_recompete_opportunities(TARGET_NAICS, months_ahead=12)

    for i, contract in enumerate(recompetes[:10], 1):
        value_m = contract.get("award_amount", 0) / 1_000_000
        report.append(f"\n{i}. {contract.get('agency', 'N/A')} — ${value_m:.1f}M")
        report.append(f"   Current Holder: {contract.get('recipient_name', 'N/A')}")
        report.append(f"   Expiring: {contract.get('period_of_performance_end', 'N/A')}")
        report.append(f"   Set-aside: {contract.get('set_aside', 'None')}")

    # Section 3: Agency Intelligence
    report.append("\n\n🏛️  SECTION 3: AGENCY SPENDING TRENDS (Last 90 Days)")
    report.append("-" * 40)

    agency_intel = analyze_agency_spending(TARGET_AGENCIES, days_back=90)

    for agency, data in agency_intel.items():
        total_m = data["total_value"] / 1_000_000
        avg_m = data["avg_contract_value"] / 1_000_000
        report.append(f"\n{agency}:")
        report.append(f"  Total: ${total_m:.1f}M across {data['total_contracts']} contracts")
        report.append(f"  Avg Award: ${avg_m:.1f}M")
        report.append(f"  Top Category: {data['top_categories'][0]['description'] if data['top_categories'] else 'N/A'}")
        report.append(f"  Large Awards (${LARGE_CONTRACT_THRESHOLD/1e6:.0f}M+): {len(data['large_contracts'])}")

    report.append("\n" + "=" * 60)
    report.append("END OF REPORT")
    report.append("=" * 60)

    return "\n".join(report)


if __name__ == "__main__":
    report = generate_weekly_report()
    print(report)

    # Optional: save to file
    filename = f"procurement_report_{datetime.now().strftime('%Y%m%d')}.txt"
    with open(filename, "w") as f:
        f.write(report)
    print(f"\n✅ Report saved to {filename}")

How to Use This for Business Development

Here are five concrete strategies:

1. Identify Your Ideal Contract Size

The federal market ranges from micro-purchases ($10K) to mega-contracts ($1B+). Use the min_value and max_value parameters to find contracts in the range where you can actually compete. Many small businesses win in the $500K–$5M range as a prime, or $5M–$50M as a subcontractor.

2. Track Your Competitors

Search by recipient_name to see who's winning contracts in your space. How many awards has your top competitor won this year? From which agencies? This tells you where to focus your relationship-building efforts.

3. Ride the Re-Compete Wave

Contracts ending within 6–12 months are gold. The incumbent has the advantage, but they're not unbeatable. Start engaging the agency 9–12 months before re-compete. The API's expiring_within_days filter makes this easy to automate.

4. Set-Aside Targeting

If your firm qualifies as a small business, woman-owned, veteran-owned, or 8(a), filter specifically for those set-asides. Competition is dramatically reduced in set-aside awards.

5. Geographic Concentration

If you're a local or regional firm, the state filter lets you see exactly what's being awarded in your area. Federal buildings, military bases, and regional offices all have procurement needs.

Understanding the Data Sources

The Government Contracts API aggregates data from:

USASpending.gov — The official database of all federal spending, updated daily
SAM.gov — System for Award Management, the official vendor registration and contract opportunities portal
FPDS-NG — Federal Procurement Data System — Next Generation

The API normalizes and enriches this data, making it far easier to work with than the raw government feeds.

Free Tier and Pricing

Getting started is completely free:

Free tier: 100 requests/month
No credit card required
Access to all core endpoints
JSON responses with full contract details

For power users — BD teams running daily alerts, analysts building dashboards, or developers integrating into CRM systems — paid tiers offer higher volume and additional data enrichment features.

Get Started Now

The Government Contracts API is available on RapidAPI. Search for "government contracts API" on RapidAPI to find the listing and subscribe to the free tier in minutes.

Once you have your API key, drop it into the Python script above, customize your target NAICS codes and agencies, and run your first procurement intelligence report. The 100 free requests per month is more than enough to run a weekly report for your entire BD team.

Final Thoughts

Federal procurement data has always been public. The problem has never been availability — it's been accessibility. The raw data portals are complex, slow, and hard to automate against.

This API changes that. With a few lines of Python and a free API key, you can build a procurement intelligence system that would have cost a six-figure consulting engagement five years ago.

Your competitors are probably not doing this yet. That's your edge.

Start your free trial: Search for "government contracts API" on RapidAPI and subscribe today. 100 free requests per month, no credit card, cancel anytime.

Good luck out there. The contracts are waiting. 🏛️

Track Insider Trading in Real Time with This Free SEC EDGAR API

linderroger-eng — Thu, 04 Jun 2026 19:40:33 +0000

Track Insider Trading in Real Time with This Free SEC EDGAR API

When corporate insiders — CEOs, CFOs, board members, and major shareholders — buy or sell their own company's stock, they're required by law to disclose it. These disclosures, filed with the SEC as Form 4, are some of the most valuable signals in public finance. And now, with the SEC EDGAR API, you can access them programmatically — for free.

In this guide, we'll walk through how to use the SEC EDGAR API to track insider trades in real time, build a Python-based monitoring script, and understand why insider buying is one of the most reliable bullish signals in investing.

Why Insider Trading Data Matters

Let's be clear: we're talking about legal insider trading — the kind that gets disclosed to the SEC within two business days of the transaction. When a company's CEO goes out and buys $2 million worth of their own stock on the open market, that's a statement. They're putting their own money where their mouth is.

Here's why insider buying is considered a bullish signal:

Information asymmetry: Insiders know the company's pipeline, contracts, and financials better than anyone. When they buy, they believe the stock is undervalued.
No obligation to buy: Unlike selling (which can happen for many reasons — diversification, taxes, liquidity), buying is almost always a deliberate vote of confidence.
Cluster buying: When multiple insiders at the same company buy stock within a short window, it's an even stronger signal.
Track record: Academic research (including studies by Seyhun, Lakonishok, and Lee) consistently shows that insider purchases outperform the market by 5–10% over the following 12 months.

The challenge has always been accessing this data in a usable form. The SEC EDGAR system is a treasure trove, but parsing raw SGML filings isn't fun. That's where this API comes in.

Introducing the SEC EDGAR API

The SEC EDGAR API wraps the raw SEC filing data into clean, structured JSON endpoints. You can query for:

Form 4 filings (insider trades)
Company filings (10-K, 10-Q, 8-K, etc.)
CIK lookups (find any company's SEC identifier)
Financial statements

The base URL is: https://sec-edgar-api-0nxw.onrender.com

And best of all — there's a free tier that lets you get started without a credit card.

Getting Started: Your First API Call

Let's start simple. Here's how to pull recent insider trades using curl:

curl -X GET "https://sec-edgar-api-0nxw.onrender.com/insider-trades?limit=10" \
  -H "Accept: application/json"

This returns the 10 most recent Form 4 filings across all companies. The response looks something like this:

{
  "trades": [
    {
      "filer_name": "SMITH JOHN R",
      "filer_title": "Chief Executive Officer",
      "company_name": "Acme Corp",
      "ticker": "ACME",
      "transaction_date": "2025-05-28",
      "transaction_type": "P",
      "shares": 50000,
      "price_per_share": 42.15,
      "total_value": 2107500,
      "shares_owned_after": 250000,
      "filing_date": "2025-05-30"
    }
  ],
  "total": 1,
  "page": 1
}

The transaction_type field uses SEC codes:

P = Purchase (open market buy) ✅ Bullish
S = Sale (open market sell)
A = Award (granted shares, options)
D = Disposition

Filtering by Company or Ticker

Want to track insider activity for a specific company? Just add a ticker parameter:

curl -X GET "https://sec-edgar-api-0nxw.onrender.com/insider-trades?ticker=AAPL&limit=20" \
  -H "Accept: application/json"

Or filter by transaction type to see only purchases:

curl -X GET "https://sec-edgar-api-0nxw.onrender.com/insider-trades?transaction_type=P&limit=50" \
  -H "Accept: application/json"

Filter by minimum transaction value (e.g., trades over $500,000):

curl -X GET "https://sec-edgar-api-0nxw.onrender.com/insider-trades?min_value=500000&transaction_type=P" \
  -H "Accept: application/json"

Building a Python Insider Trade Monitor

Now let's build something actually useful — a Python script that polls the API and alerts you when significant insider buying occurs.

import requests
import time
from datetime import datetime, timedelta

# Configuration
BASE_URL = "https://sec-edgar-api-0nxw.onrender.com"
API_KEY = "your_api_key_here"  # Get yours from RapidAPI
MIN_PURCHASE_VALUE = 100_000   # Alert on buys > $100k
WATCH_TICKERS = ["AAPL", "MSFT", "NVDA", "TSLA"]  # Optional: specific watchlist

def get_insider_trades(ticker=None, transaction_type="P", days_back=7, limit=50):
    """
    Fetch recent insider trades from the SEC EDGAR API.

    Args:
        ticker: Optional stock ticker to filter by
        transaction_type: 'P' for purchases, 'S' for sales
        days_back: How many days to look back
        limit: Max number of results

    Returns:
        List of trade dictionaries
    """
    endpoint = f"{BASE_URL}/insider-trades"

    params = {
        "transaction_type": transaction_type,
        "limit": limit,
        "days_back": days_back
    }

    if ticker:
        params["ticker"] = ticker

    headers = {
        "Accept": "application/json",
        "x-api-key": API_KEY
    }

    response = requests.get(endpoint, params=params, headers=headers)
    response.raise_for_status()

    data = response.json()
    return data.get("trades", [])


def find_cluster_buying(days_back=30, min_insiders=3):
    """
    Find companies where multiple insiders are buying — the strongest signal.

    Args:
        days_back: Look-back window in days
        min_insiders: Minimum number of distinct insiders buying

    Returns:
        Dictionary of {ticker: [trades]} for cluster buys
    """
    trades = get_insider_trades(transaction_type="P", days_back=days_back, limit=200)

    # Group by ticker
    by_ticker = {}
    for trade in trades:
        ticker = trade.get("ticker", "UNKNOWN")
        if ticker not in by_ticker:
            by_ticker[ticker] = []
        by_ticker[ticker].append(trade)

    # Filter for cluster buying
    clusters = {
        ticker: trade_list
        for ticker, trade_list in by_ticker.items()
        if len(set(t["filer_name"] for t in trade_list)) >= min_insiders
    }

    return clusters


def calculate_signal_strength(trades):
    """
    Score insider buying signal strength based on:
    - Number of distinct insiders buying
    - Seniority of insiders (CEO/CFO weighted higher)
    - Total dollar value of purchases
    - Recent concentration (how recent the buys are)
    """
    if not trades:
        return 0

    score = 0
    senior_titles = {"chief executive officer", "ceo", "chief financial officer", 
                     "cfo", "president", "chairman", "director"}

    insiders = set()
    total_value = 0

    for trade in trades:
        filer = trade.get("filer_name", "")
        title = trade.get("filer_title", "").lower()
        value = trade.get("total_value", 0)

        insiders.add(filer)
        total_value += value

        # Bonus points for senior executives
        if any(t in title for t in senior_titles):
            score += 3
        else:
            score += 1

    # Scale by number of distinct insiders
    score += len(insiders) * 2

    # Scale by total dollar amount (logarithmic)
    if total_value > 0:
        import math
        score += math.log10(total_value)

    return round(score, 2)


def monitor_insider_buying(check_interval_minutes=60):
    """
    Continuously monitor for significant insider buying and print alerts.
    """
    print(f"🔍 Starting insider trade monitor...")
    print(f"   Min purchase alert: ${MIN_PURCHASE_VALUE:,}")
    print(f"   Check interval: every {check_interval_minutes} minutes\n")

    seen_filings = set()

    while True:
        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}] Checking for new insider purchases...")

        try:
            trades = get_insider_trades(transaction_type="P", days_back=2, limit=100)

            new_significant = []
            for trade in trades:
                filing_key = f"{trade.get('ticker')}_{trade.get('filer_name')}_{trade.get('transaction_date')}"

                if filing_key in seen_filings:
                    continue

                seen_filings.add(filing_key)
                value = trade.get("total_value", 0)

                if value >= MIN_PURCHASE_VALUE:
                    new_significant.append(trade)

            if new_significant:
                print(f"\n🚨 SIGNIFICANT INSIDER PURCHASES DETECTED:\n")
                for trade in sorted(new_significant, key=lambda x: x.get("total_value", 0), reverse=True):
                    print(f"  📈 {trade['ticker']} — {trade['company_name']}")
                    print(f"     Insider: {trade['filer_name']} ({trade['filer_title']})")
                    print(f"     Purchased: {trade['shares']:,} shares @ ${trade['price_per_share']:.2f}")
                    print(f"     Total Value: ${trade['total_value']:,.0f}")
                    print(f"     Filed: {trade['filing_date']}\n")
            else:
                print("   No new significant purchases found.")

        except requests.RequestException as e:
            print(f"   API error: {e}")

        # Check for cluster buying weekly
        print("\n📊 Checking for cluster buying patterns...")
        clusters = find_cluster_buying(days_back=30, min_insiders=3)

        if clusters:
            print(f"   Found cluster buying in {len(clusters)} companies:")
            for ticker, cluster_trades in clusters.items():
                strength = calculate_signal_strength(cluster_trades)
                total = sum(t.get("total_value", 0) for t in cluster_trades)
                print(f"   🔥 {ticker}: {len(cluster_trades)} purchases, ${total:,.0f} total (signal: {strength})")

        print(f"\nNext check in {check_interval_minutes} minutes...\n")
        time.sleep(check_interval_minutes * 60)


if __name__ == "__main__":
    # Quick demo — get top 10 largest insider purchases this week
    print("Top 10 Largest Insider Purchases (Last 7 Days):\n")
    trades = get_insider_trades(transaction_type="P", days_back=7, limit=100)

    # Sort by total value
    trades.sort(key=lambda x: x.get("total_value", 0), reverse=True)

    for i, trade in enumerate(trades[:10], 1):
        print(f"{i}. {trade.get('ticker', 'N/A')} — {trade.get('company_name', 'N/A')}")
        print(f"   {trade.get('filer_title', 'N/A')}: {trade.get('filer_name', 'N/A')}")
        print(f"   {trade.get('shares', 0):,} shares @ ${trade.get('price_per_share', 0):.2f} = ${trade.get('total_value', 0):,.0f}\n")

    # Find cluster buys
    print("\nCluster Buying (3+ Insiders, Last 30 Days):")
    clusters = find_cluster_buying()
    for ticker, cluster_trades in clusters.items():
        print(f"  {ticker}: {len(cluster_trades)} insider purchases")

Real-World Use Cases

Here are some practical ways to use this data:

1. Pre-Earnings Insider Scan
Run a scan 30–60 days before earnings season. Significant insider buying before earnings often signals management confidence in the upcoming results.

2. Sector Rotation Detection
If you see cluster buying across multiple companies in the same sector (e.g., energy or biotech), it might signal a sector-wide catalyst that insiders are aware of.

3. Turnaround Plays
Look for insider buying in beaten-down stocks. When executives buy shares after a significant selloff, it often marks a bottom.

4. Short Squeeze Setup Screener
Combine insider buying data with high short interest stocks. When heavily shorted companies start showing significant insider purchases, it can be a powerful counter-signal.

API Tiers and Rate Limits

The SEC EDGAR API offers a free tier that lets you:

Make up to 100 requests per month at no cost
Access all core endpoints including /insider-trades
No credit card required to get started

For more serious use cases — running a monitor script, powering a dashboard, or building a fintech app — paid tiers offer higher rate limits and additional endpoints.

Getting Your API Key

The SEC EDGAR API is available on RapidAPI. Search for "SEC EDGAR API by linderroger" on RapidAPI to find the listing, subscribe to the free tier, and grab your API key.

Once you have it, replace your_api_key_here in the Python code above with your actual key, and you're live.

What to Look for in the Data

Not all insider buying is equally meaningful. Here's a quick cheat sheet:

Higher-signal purchases:

CEO or CFO buying on the open market
Large dollar amounts (>$500K personally)
Multiple insiders buying within the same 2-week window
Buying after a significant stock decline
Insiders haven't sold in the past year

Lower-signal purchases:

Purchases from stock option exercises (marked M or A)
Very small amounts relative to insider's known wealth
Automatic/programmatic purchasing plans (Rule 10b5-1)

Conclusion

Insider trading data is one of the few legal edges available to retail investors. It's public information, disclosed within 48 hours, and tells you exactly what the people with the most information about a company are doing with their own money.

With the SEC EDGAR API, you can access this data programmatically, build custom screens, and potentially catch big moves before they happen.

Ready to get started? Search for "SEC EDGAR API by linderroger" on RapidAPI and start your free tier today. The free plan gives you 100 requests/month — more than enough to build a functional insider trade monitor and see real value before upgrading.

Happy trading. 📈

I Built a Free API to Search SEC EDGAR by Ticker Symbol (No CIK Lookup Needed)

linderroger-eng — Thu, 04 Jun 2026 19:28:21 +0000

Every developer who has tried to pull financial data from the SEC knows the pain. You want Apple's annual reports. Simple enough, right?

Wrong.

First, you discover SEC EDGAR doesn't know what "AAPL" means. You need a CIK — a Central Index Key — which for Apple is 0000320193. So you go hunt that down. Then you hit the EDGAR full-text search API, wrestle with paginated XML responses, try to parse XBRL inline documents, decode filing index pages, and somehow extract the actual data buried inside. By the time you've got one number out, you've written 200 lines of boilerplate.

I got tired of doing this for every project. So I built a wrapper API that lets you query SEC EDGAR by ticker symbol and get clean JSON back.

The Problem with Raw SEC EDGAR

Here's what it actually looks like to pull Apple's 10-K filings from the raw SEC API:

import requests

ticker = "AAPL"
# Step 1: Hit the company search to find CIK...
r = requests.get("https://efts.sec.gov/LATEST/search-index?q=AAPL&forms=10-K")
# Step 2: Parse XML response...
# Step 3: Extract CIK from nested structure...
# Step 4: Hit another endpoint with the CIK...
# Step 5: Parse filing index pages...
# Step 6: Decode inline XBRL inside HTML...
# 200 lines later... 😩

Every project starts with the same CIK lookup ritual. Then you deal with:

XBRL hell — financial facts buried in inline XBRL tags inside HTML, or separate XML files with namespaced taxonomies
Accession number formatting — 0000320193-24-000123 needs reformatting to build valid URLs
Rate limits with no clear docs — EDGAR wants custom User-Agent headers and throttles aggressively
Inconsistent schemas — different filers use different XBRL concepts for the same metric

There had to be a better way.

The Solution: A Ticker-First SEC EDGAR API

I built a REST API that handles all the CIK resolution, EDGAR crawling, and data normalization for you. You pass a ticker symbol. You get clean JSON.

Base URL: https://sec-edgar-api-0nxw.onrender.com
Docs: https://sec-edgar-api-0nxw.onrender.com/docs
Auth: Free — include an X-API-Key header (auto-registers, 100 req/day, no credit card)

Endpoints at a glance

GET /ticker-lookup?ticker=NVDA — resolve ticker → CIK + company name
GET /filings?ticker=AAPL&form_type=10-K — list recent SEC filings
GET /insider-trades?ticker=TSLA — Form 4 insider transaction filings
GET /company-facts?ticker=MSFT&concept=Revenues — XBRL financial facts by concept

Real API Responses

Let's walk through each endpoint with live data.

1. Ticker Lookup

curl -H "X-API-Key: YOUR_KEY" \
  "https://sec-edgar-api-0nxw.onrender.com/ticker-lookup?ticker=NVDA"

Response:

{
    "ticker": "NVDA",
    "cik": "0001045810",
    "company_name": "NVIDIA CORP",
    "source": "SEC EDGAR"
}

No manual CIK lookup. No EDGAR search pages. One call, instant CIK resolution.

2. SEC Filings by Ticker

curl -H "X-API-Key: YOUR_KEY" \
  "https://sec-edgar-api-0nxw.onrender.com/filings?ticker=AAPL&form_type=10-K"

Response:

{
    "ticker": "AAPL",
    "company": "Apple Inc.",
    "cik": "0000320193",
    "count": 10,
    "filings": [
        {
            "form_type": "10-K",
            "filing_date": "2025-10-31",
            "accession_number": "0000320193-25-000079",
            "document_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/aapl-20250927.htm"
        },
        {
            "form_type": "10-K",
            "filing_date": "2024-11-01",
            "accession_number": "0000320193-24-000123",
            "document_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm"
        }
    ]
}

You get direct document URLs — no accession number reformatting, no index page parsing.

3. Insider Trades (Form 4)

curl -H "X-API-Key: YOUR_KEY" \
  "https://sec-edgar-api-0nxw.onrender.com/insider-trades?ticker=TSLA"

Response:

{
    "ticker": "TSLA",
    "company": "Tesla, Inc.",
    "cik": "0001318605",
    "count": 10,
    "insider_trades": [
        {
            "form_type": "4",
            "filing_date": "2026-05-15",
            "accession_number": "0001104659-26-062860",
            "reporter": "See filing",
            "filing_url": "https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=0001318605&type=4"
        },
        {
            "form_type": "4",
            "filing_date": "2026-05-04",
            "accession_number": "0001104659-26-055079",
            "reporter": "See filing"
        }
    ],
    "note": "For full transaction details (shares, price, buy/sell), fetch the individual filing document.",
    "source": "SEC EDGAR Form 4"
}

Tesla insiders filed Form 4s as recently as May 2026. This is the raw data behind every "insider selling" alert on financial news sites.

4. Company Financial Facts (XBRL)

curl -H "X-API-Key: YOUR_KEY" \
  "https://sec-edgar-api-0nxw.onrender.com/company-facts?ticker=MSFT&concept=Revenues"

Response:

{
    "ticker": "MSFT",
    "company": "MICROSOFT CORP",
    "concept": "Revenues",
    "label": "Revenues",
    "description": "Amount of revenue recognized from goods sold, services rendered, insurance premiums, or other activities...",
    "recent_values": [
        {
            "value": 62484000000,
            "unit": "USD",
            "period_start": "2009-07-01",
            "period_end": "2010-06-30",
            "form": "10-K",
            "filed": "2010-07-30"
        },
        {
            "value": 36148000000,
            "unit": "USD",
            "period_start": "2010-07-01",
            "period_end": "2010-12-31",
            "form": "10-Q",
            "filed": "2011-01-27"
        }
    ]
}

Microsoft's revenue pulled straight from their XBRL filings — no taxonomy parsing required.

What Can You Build With This?

Stock Screeners
Pull 10-K and 10-Q filings across multiple tickers to build revenue trend screens, debt-to-equity comparisons, or custom fundamental filters.

Insider Trade Monitors
Form 4 filings are legally required within 2 business days of a transaction. Poll this endpoint on a schedule to build real-time insider activity alerts.

Compliance and Due Diligence Tools
Legal teams and investors need quick access to a company's SEC filing history. Build internal tools that surface relevant filings without manual EDGAR navigation.

Fintech Apps and Dashboards
Embed SEC filing links, revenue history, or insider activity into investor dashboards, portfolio trackers, or research platforms.

LLM / AI Research Agents
Feed filing URLs or XBRL data directly into AI pipelines for earnings analysis, risk assessment, or automated research summaries.

Python Quick Start

import requests

BASE_URL = "https://sec-edgar-api-0nxw.onrender.com"
API_KEY = "your-key-here"  # auto-registered on first use

headers = {"X-API-Key": API_KEY}

def get_filings(ticker, form_type="10-K"):
    r = requests.get(
        f"{BASE_URL}/filings",
        params={"ticker": ticker, "form_type": form_type},
        headers=headers
    )
    r.raise_for_status()
    return r.json()

def get_insider_trades(ticker):
    r = requests.get(
        f"{BASE_URL}/insider-trades",
        params={"ticker": ticker},
        headers=headers
    )
    r.raise_for_status()
    return r.json()

def get_revenue_history(ticker):
    r = requests.get(
        f"{BASE_URL}/company-facts",
        params={"ticker": ticker, "concept": "Revenues"},
        headers=headers
    )
    r.raise_for_status()
    return r.json()

# Pull Apple's 10-K filings
filings = get_filings("AAPL", "10-K")
print(f"Found {filings['count']} 10-K filings for {filings['company']}")
for f in filings["filings"][:3]:
    print(f"  {f['filing_date']} — {f['document_url']}")

# Monitor Tesla insider trades
trades = get_insider_trades("TSLA")
print(f"\n{trades['count']} recent insider filings for {trades['company']}")
for t in trades["insider_trades"][:3]:
    print(f"  {t['filing_date']} — {t['accession_number']}")

# Fetch Microsoft revenue data
revenue = get_revenue_history("MSFT")
print(f"\n{revenue['company']} Revenue ({revenue['concept']}):")
for v in revenue["recent_values"][:3]:
    print(f"  {v['period_end']}: ${v['value']:,.0f}")

Resources

📊 Visualize the trends you find in SEC data with TradingView indicators: TradingView Tools

🛠️ Browse my recommended developer tools: Amazon Developer Picks

Get Started

API Base URL: https://sec-edgar-api-0nxw.onrender.com
Interactive Docs: https://sec-edgar-api-0nxw.onrender.com/docs
Free tier: 100 requests/day, no credit card required

Your X-API-Key auto-registers on first use — just pick a key name and start querying.

Have a use case in mind? Drop it in the comments — I'd love to hear what you're building with public financial data.

Get weekly AI business & automation insights → AI Business Trends on Substack

12 Filters for Finding Mispriced Markets on Polymarket (Free Checklist)

linderroger-eng — Tue, 02 Jun 2026 18:09:17 +0000

Most Polymarket traders browse markets the same way everyone else does — scrolling through trending topics, picking sides based on gut feelings, and wondering why they keep losing money. The traders who consistently profit do something different: they filter.

This post breaks down the 12 filters I use to identify mispriced markets before placing a single dollar. Not vague principles — specific signals you can check in under five minutes per market.

Why Mispricing Happens on Polymarket

Prediction markets are more efficient than most people think, but inefficiencies exist. They cluster around low-liquidity markets, fast-moving news cycles, and questions where the crowd has emotional rather than informational bias. Your job is to find those pockets before the market corrects.

The 12 Filters

Filter 1: Liquidity Floor Check
Only trade markets with at least $5,000 in total liquidity. Below that, a few large bets can move prices dramatically, making your exit painful.

Filter 2: Resolution Criteria Clarity
Read the resolution criteria word-for-word. Ambiguous wording means contested resolutions or operator discretion. Pass on anything unclear.

Filter 3: Time-to-Resolution Efficiency
Calculate your annualized return. A market at 94¢ with 60 days to resolution yields ~12% annualized. The same market with 365 days yields ~6%. Capital efficiency matters.

Filter 4: News Lag Detection
Check when the market price last moved vs. when relevant news broke. If there's a lag, the market may still be catching up. Google News timestamps are your friend.

Filter 5: Base Rate vs. Market Price Divergence
Find the historical base rate for the event type. If the market price diverges from base rates by more than 10 points without a clear narrative reason, investigate.

Filter 6: Correlated Market Consistency
Polymarket often runs multiple related markets simultaneously. Check that implied probabilities are internally consistent. Arbitrage hides in the gaps.

Filter 7: Volume Trend vs. Price Trend
A price moving up on declining volume is a weak signal. Rising price on rising volume has real conviction behind it.

Filter 8: Crowd Sentiment Proxy
Check Twitter/X for the prevailing narrative. If sentiment is overwhelmingly one-sided but the market is balanced, that asymmetry is worth probing.

Filter 9: Operator Track Record
Political and sports markets tend to resolve cleanly. Novel or complex conditional markets carry more operator risk. Check the market creator's history.

Filter 10: Kelly Criterion Sanity Check
Before sizing any position: Edge / Odds = Optimal Fraction. If your edge is 5% betting YES at 70¢, your Kelly fraction is ~7% of bankroll. Never exceed full Kelly.

Filter 11: Whale Wallet Activity
Polymarket is on-chain. Use Polygonscan or whale-tracking tools to see where large traders are positioned. Smart money isn't always right, but it's worth knowing.

Filter 12: Reversion Potential Timing
Markets frequently overcorrect on dramatic news, then revert over 24-72 hours. The reversion window is often where the edge lives.

How to Use These Filters Together

Run each market through all 12. You're looking for markets that pass at least 8-9 — that's your signal a genuine edge exists. The more filters a market fails, the more you should question whether you have informational advantage or just conviction.

The discipline is in the checklist, not the instinct.

Get the Full Checklist (Free)

I've formatted all 12 filters into a one-page checklist you can use before every Polymarket trade. Includes scoring guidelines, a resolution risk rubric, and the Kelly formula pre-filled.

👉 Download the Free Polymarket Edge Checklist

No email required. Use it, share it, and if it helps you find your first mispriced market — come back and let me know in the comments.

Polymarket trading involves real financial risk. This article is for educational purposes only.

I Built a REST API That Wraps USASpending.gov, SAM.gov and Grants.gov Into One Clean Endpoint

linderroger-eng — Tue, 02 Jun 2026 16:45:48 +0000

The Problem

Working with US government spending data is painful.

USASpending.gov requires complex POST payloads with nested JSON filters
SAM.gov needs API key registration and has rate limits
Grants.gov has its own completely different format

Every developer building govtech tools has to figure all this out from scratch. I got tired of it.

What I Built

A single REST API that normalizes all three sources into clean, consistent JSON responses.

One GET request. Real data. No auth headaches.

# Get top DoD contracts right now
curl "https://government-contracts-grants-api1.p.rapidapi.com/contracts?agency=Department%20of%20Defense&limit=5" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: government-contracts-grants-api1.p.rapidapi.com"

Real Data Example

Here is what comes back — actual federal contracts, not mock data:

{
  "count": 3,
  "source": "USASpending.gov",
  "contracts": [
    {
      "contract_id": "HT940216C0001",
      "recipient": "HUMANA GOVERNMENT BUSINESS INC",
      "agency": "Department of Defense",
      "amount_usd": 51269205263.03,
      "start_date": "2016-08-01",
      "end_date": "2025-12-31"
    },
    {
      "contract_id": "DENA0003525",
      "recipient": "NATIONAL TECHNOLOGY & ENGINEERING SOLUTIONS OF SANDIA, LLC",
      "agency": "Department of Energy",
      "amount_usd": 42370311400.75,
      "start_date": "2017-01-18",
      "end_date": "2027-04-30"
    }
  ]
}

Endpoints

GET /contracts — Filter by agency, amount, keyword
GET /grants — Federal grants from USASpending.gov
GET /agencies — All federal agencies with budget data

Use Cases

GovCon intelligence — Track competitor contract wins in real time

Business development — Identify which agencies are spending in your sector

Grant research — Find federal grants filtered by agency and dollar amount

Compliance tools — Build apps on top of real procurement data without scraping

Market analysis — Analyze federal spending trends across agencies

Why Not Just Use The Raw APIs?

You can. But:

USASpending requires a POST with nested filter objects just to search
You need separate auth flows for each source
Response formats are completely different across sources
No single query spans all three datasets

This API handles all of that so you can focus on building.

Free Tier Available

Free tier includes 100 requests/month — enough to prototype and test.

Find it on RapidAPI: Government Contracts & Grants API

Happy to add endpoints based on what people actually need — drop a comment below.

DEV Community: linderroger-eng

One API Key for Government Contracts, SEC Filings, FDA Alerts, and Macro Data

What if one API key could do it all?

The Problem: 4 APIs, 4 Headaches

The Solution: One Unified Proxy

Code Examples: 4 Endpoints, One Key

1. Government Contracts

2. SEC EDGAR Filings

3. FDA Drug Adverse Events

4. Macro Economic Indicators

JavaScript Quick Start

Pricing

Get Your Key

Bonus: Embeddable Widgets

The Bottom Line

Build a Recession Indicator with Unemployment + Inflation Data (Free API)

Build a Recession Indicator with Unemployment + Inflation Data (Free API)

What You'll Build

The API at a Glance

Step 1: Get Live Unemployment Data

Step 2: Get Live Inflation Data

Step 3: Get the Full Macro Snapshot in One Call

Step 4: Build the Recession Indicator in Python

Sample Output

Bonus: Compare GDP Across Countries

What to Build Next

API Pricing

Get Access

Stay in the Loop

Embed Live Government Contracts & Financial Data on Any Website in 10 Lines of HTML

The 10-Line Embed

What Data Do You Get?

1. contracts — Live Government Contract Awards

2. edgar — SEC Insider Trades

3. fda — FDA Device Recalls

4. macro — US Macro Indicators

How It Works Under the Hood

Customization Options

Real-World Use Cases

🏛️ Government Contractor Tracking Site

📊 Financial News Dashboard

💊 Pharma Compliance Portal

📈 Economic Research Blog

Pricing

Getting Started

Why This Approach?

Try It Now

Building a Pharma Compliance Alert System with the FDA Drug & Safety API

Building a Pharma Compliance Alert System with the FDA Drug & Safety API

Why Build Your Own Compliance Monitor?

The API: Endpoints We'll Use

Step 1: Explore Enforcement Actions

Step 2: Monitor Device Recalls

Step 3: Track Adverse Event Spikes

Step 4: The Python Compliance Alert Script

Step 5: Automate with Cron or a Serverless Scheduler

What to Build on Top of This

Get API Access

Stay in the Loop

I Built a Free API for FDA Drug Data — Adverse Events, Recalls, and Drug Labels by Name

The Problem with openFDA

What I Built

Real Examples — Try These Right Now

1. Adverse Events for Ozempic

2. Drug Label for Tylenol

3. Medical Device Recalls — Insulin Pumps

Python Code: Build an Adverse Event Monitor

Who Is This For?

Pricing

Other APIs in the Suite

The Broader Point

Get Started

How to Find $10M+ Government Contracts Before Your Competitors Do

How to Find $10M+ Government Contracts Before Your Competitors Do

The $700 Billion Opportunity Most Businesses Ignore

Introducing the Government Contracts API

Your First API Call: Finding Large Recent Contracts

Advanced Filtering: Finding Your Opportunities

Building a Procurement Intelligence Dashboard in Python

How to Use This for Business Development

1. `contracts` — Live Government Contract Awards

2. `edgar` — SEC Insider Trades

3. `fda` — FDA Device Recalls

4. `macro` — US Macro Indicators