How I Built AI Agents with Free Government Economic Data APIs

Mar 19, 2026

Cowrie

Dev @ Bswen

I was building a trading research agent last month, and I hit a wall. My agent needed economic indicators - unemployment rates, CPI, GDP growth - but every data provider I found wanted thousands per month for API access.

Bloomberg Terminal? $24,000/year. Refinitiv? Enterprise pricing. Even “budget” options were hundreds monthly.

“I guess macro data is just expensive,” I told myself. Then I discovered I was completely wrong.

The Misconception

Here’s what I assumed:

• Quality economic data = expensive subscriptions
• Free data = unreliable, delayed, or limited
• Government sources = complicated, slow, or non-existent

I spent weeks trying to scrape economic data from various websites. My code would break constantly when they changed their HTML structure. I had no historical data. Rate limiting was a nightmare.

scraper.py

# My terrible approach
import requests
from bs4 import BeautifulSoup

def get_unemployment_rate():
    # This broke every few weeks
    url = "https://some-website.com/unemployment"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    rate = soup.find('div', class_='rate').text
    return float(rate.strip('%'))

The irony? All the data I was desperately scraping was available for free through official government APIs the entire time.

Discovery: FRED API

Someone on Reddit mentioned FRED (Federal Reserve Economic Data) had a free API. I was skeptical - how could 800,000+ economic time series be free?

I registered for an API key (took 30 seconds), and within minutes I had access to:

• Unemployment rates (UNRATE)
• Consumer Price Index (CPIAUCSL)
• GDP data
• Federal funds rate
• M2 money supply
• Industrial production
• Mortgage rates

fred_agent.py

import os
import requests
from typing import Optional

class FREDAgent:
    """AI agent component for FRED economic data."""

    BASE_URL = "https://api.stlouisfed.org/fred"

    def __init__(self, api_key: Optional[str] = None):
        self.api_key = api_key or os.environ.get("FRED_API_KEY")
        if not self.api_key:
            raise ValueError("FRED API key required")

    def get_series(
        self,
        series_id: str,
        observation_start: Optional[str] = None,
        observation_end: Optional[str] = None
    ) -> dict:
        """Fetch economic time series data.

        Args:
            series_id: FRED series ID (e.g., 'UNRATE' for unemployment)
            observation_start: Start date YYYY-MM-DD
            observation_end: End date YYYY-MM-DD
        """
        params = {
            "series_id": series_id,
            "api_key": self.api_key,
            "file_type": "json"
        }

        if observation_start:
            params["observation_start"] = observation_start
        if observation_end:
            params["observation_end"] = observation_end

        try:
            response = requests.get(
                f"{self.BASE_URL}/series/observations",
                params=params,
                timeout=30
            )
            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            print(f"FRED API error: {e}")
            return {"error": str(e), "observations": []}

    def get_latest_unemployment(self) -> Optional[float]:
        """Get most recent US unemployment rate."""
        data = self.get_series("UNRATE")
        if data.get("observations"):
            latest = data["observations"][-1]
            return float(latest["value"])
        return None

The response came back instantly with clean JSON data. No scraping. No HTML parsing. Just authoritative government data with decades of history.

BLS API: Even Simpler

The Bureau of Labor Statistics was next. CPI data, unemployment rates, wage growth, producer price indices - all available through their API.

What surprised me: you don’t even need an API key for basic access. Registered users get higher rate limits, but you can start immediately.

bls_agent.py

class BLSAgent:
    """AI agent component for BLS labor statistics."""

    BASE_URL = "https://api.bls.gov/publicAPI/v2/timeseries/data"

    def __init__(self, api_key: Optional[str] = None):
        # BLS allows unregistered access with lower limits
        self.api_key = api_key or os.environ.get("BLS_API_KEY")

    def get_cpi(self, years: list[str]) -> dict:
        """Fetch Consumer Price Index data.

        Args:
            years: List of years to fetch (e.g., ['2023', '2024'])
        """
        headers = {"Content-Type": "application/json"}
        payload = {
            "seriesid": ["CUUR0000SA0"],  # CPI for All Urban Consumers
            "startyear": years[0],
            "endyear": years[-1]
        }

        if self.api_key:
            payload["registrationkey"] = self.api_key

        try:
            response = requests.post(
                self.BASE_URL,
                json=payload,
                headers=headers,
                timeout=30
            )
            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            print(f"BLS API error: {e}")
            return {"error": str(e)}

World Bank API: No Key Required

For global macro data, the World Bank API is a hidden gem. GDP, inflation, trade data for every country - and zero authentication required.

worldbank_agent.py

def get_global_gdp(country_code: str = "USA") -> dict:
    """Fetch GDP data from World Bank API.

    Note: No API key required - immediate access.
    """
    url = f"http://api.worldbank.org/v2/country/{country_code}/indicator/NY.GDP.MKTP.CD"

    params = {
        "format": "json",
        "per_page": 100
    }

    response = requests.get(url, params=params, timeout=30)
    return response.json()

I now had access to:

• US economic indicators (FRED)
• Labor market data (BLS)
• Global economic data (World Bank)

All for free. All with clean APIs. All authoritative government sources.

Building a Macro-Aware Agent

With these APIs, I built a function that gives my agents real economic context:

macro_agent.py

from datetime import datetime

def analyze_macro_conditions() -> dict:
    """Agent function to assess current macro environment."""

    fred = FREDAgent()

    # Get key indicators
    indicators = fred.get_macro_indicators()

    # Agent logic based on economic data
    analysis = {
        "timestamp": datetime.now().isoformat(),
        "indicators": indicators,
        "signals": {}
    }

    # Example: Fed funds rate trend
    if indicators.get("fed_funds"):
        rate = indicators["fed_funds"]["latest"]
        if rate > 5.0:
            analysis["signals"]["monetary_policy"] = "restrictive"
        elif rate < 2.0:
            analysis["signals"]["monetary_policy"] = "accommodative"
        else:
            analysis["signals"]["monetary_policy"] = "neutral"

    return analysis

fred_agent.py

def get_macro_indicators(self) -> dict:
    """Fetch multiple key indicators for agent analysis."""
    indicators = {
        "unemployment": "UNRATE",
        "cpi": "CPIAUCSL",
        "gdp": "GDP",
        "fed_funds": "FEDFUNDS",
        "m2_money_supply": "M2SL"
    }

    results = {}
    for name, series_id in indicators.items():
        data = self.get_series(series_id)
        if data.get("observations"):
            results[name] = {
                "latest": float(data["observations"][-1]["value"]),
                "date": data["observations"][-1]["date"]
            }
    return results

Now when my agent analyzes market conditions, it has actual economic context. Not scraped data that breaks weekly. Not expensive subscriptions. Free, authoritative government data.

Why This Matters for AI Agents

The Reddit discussion where I discovered these APIs made an important observation: government economic data is “consistently underused by developers and consistently useful for macro-aware agents.”

For AI agents specifically, this data enables:

1. Contextual Awareness: Understanding market movements in economic context
2. Predictive Features: Leading indicators improve forecasting models
3. Risk Assessment: Macro conditions inform risk calculations
4. Regulatory Compliance: Authoritative sources for reporting

The competitive advantage isn’t in having access - everyone has access. It’s in actually using it.

Caching for Production

One mistake I made initially: hitting the APIs on every request. Even free APIs have rate limits. I added intelligent caching:

cached_agent.py

import time

class CachedEconomicAgent:
    """Economic data agent with intelligent caching."""

    def __init__(self):
        self._cache = {}
        self._cache_time = {}
        self.cache_ttl = 3600  # 1 hour for most economic data

    def get_with_cache(self, series_id: str, fetch_func) -> dict:
        """Cached fetch with TTL."""
        now = time.time()

        if series_id in self._cache:
            if now - self._cache_time.get(series_id, 0) < self.cache_ttl:
                return self._cache[series_id]

        data = fetch_func(series_id)
        self._cache[series_id] = data
        self._cache_time[series_id] = now
        return data

    def clear_stale_cache(self):
        """Remove expired cache entries."""
        now = time.time()
        stale = [
            k for k, t in self._cache_time.items()
            if now - t > self.cache_ttl
        ]
        for k in stale:
            del self._cache[k]
            del self._cache_time[k]

Economic data updates monthly at most (unemployment, CPI) or quarterly (GDP). Caching for an hour is more than sufficient for real-time agent workflows.

Common Pitfalls

I made these mistakes so you don’t have to:

1. Ignoring rate limits: Even free APIs have constraints. Check the docs.
2. No error handling: Government APIs can be slow or temporarily unavailable. Always handle failures gracefully.
3. Missing metadata: Series definitions matter. UNRATE vs LNS14000000 - different methodologies, different interpretations.
4. Hardcoding URLs: API endpoints can change. Use configuration.
5. Not checking update frequency: Some indicators are monthly, others quarterly. Don’t assume daily updates.

Getting Started

1. Register for a free FRED API key at https://fred.stlouisfed.org/docs/api/api_key.html
2. Explore BLS API documentation at https://www.bls.gov/developers/
3. Access World Bank data immediately (no key needed) at https://datahelpdesk.worldbank.org/knowledgebase/articles/889392

The entire setup took me under an hour. The data quality matches what institutional investors pay thousands for. The only real cost is learning the API parameters and series IDs.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags:

• ai-agents
• ai
• backend
• python
• automation

When Should AI Agents Use Free Public APIs Versus Paid API Aggregators?

What Tasks is Claude Haiku Best Suited For? Real-World Use Cases