Chapter 3: Your First API Call

In the next few minutes, you're going to fetch live data from the internet with Python. Not a simulation and not a pre-baked tutorial dataset, but real information from actual servers, the same way Instagram loads your feed or your weather app shows today's forecast.

This is the moment where everything starts to click. You've installed Python, set up your environment, and learned the core ideas. Now you'll see APIs in action, in real time. By the end of this chapter, you'll have made dozens of successful requests and you'll understand, step by step, how connected applications talk to servers.

Every time you open a weather app, scroll social media, or check your bank balance, your device is quietly making API calls. These conversations happen millions of times per second across the internet. In this chapter, you join the developers who build those conversations on purpose, instead of just watching them happen.

By the end of this chapter, you'll be able to:

• Make your first API request in Python using the requests library.
• Explain, in plain language, how APIs connect your programs to real data on servers.
• Read and interpret JSON responses from APIs.
• Handle basic errors when network requests fail instead of letting your program crash.
• Use query parameters to customize and refine your API requests.
• Build a complete program that integrates multiple APIs into one script.

The best way to understand APIs is to see them in action. We'll start with something simple: calling an API directly in your browser, then repeating the same call in Python. The Cat Facts API is a small, free service that returns random facts about cats. When you visit its URL in your browser, you're seeing exactly what the server sends back.

Access An API In Your Browser

Before writing any Python code, let's see what an API response actually looks like. Open this URL in your browser. This is you making an API request manually:

https://catfact.ninja/fact

You'll see a block of raw text in a format called JSON. It might look a little dense at first, but it's just structured text that your computer can read easily. Your browser sent a request to the server, and the server responded with this JSON. A Python program would receive the very same data. Under the hood, almost all API responses look like this: structured text that code can parse and work with.

Now Try It in Python

Now let's make that exact same request using Python. You're going to write a few lines that connect to a live server, send a request, and print the data that comes back. Notice how little code you need-the requests library hides all the low-level networking details for you.

import requests

url = "https://catfact.ninja/fact"
response = requests.get(url)        
# ← Your computer sent a request to a server
# ← The server sent back data

print(response.text)
# ← You're seeing that data                

Run this code. You'll see the same JSON you saw in your browser, but this time it came from Python. This simple pattern—import requests, call requests.get(url), and examine the response—is the foundation you'll use in hundreds of scripts. The server doesn't know whether a browser or a Python script made the request; it simply sends back the same data either way.

When you call an API, the server doesn't just send raw text. It packages everything into an HTTP response with status codes, headers, and a body. The status code tells you what happened—200 means success, 404 means not found, 500 means server error. Headers include metadata like content type and encoding. The body contains the actual data, usually in JSON format.

In the example above, response.text gives you the body as a raw string. But the response object has other useful properties. Here's what you can access:

import requests

url = "https://catfact.ninja/fact"
response = requests.get(url)

print(f"Status Code: {response.status_code}")
print(f"Content Type: {response.headers['Content-Type']}")
print(f"Response Body: {response.text}")

This prints the status code (200 if successful), the content type (likely "application/json"), and the raw response body. Understanding these properties helps you debug when things go wrong. If you get a 404, the API endpoint doesn't exist. If you see a 500, the server had an internal error. Knowing what each status code means is crucial for building robust API integrations.

JSON (JavaScript Object Notation) is the standard format for API responses. It looks like Python dictionaries and lists, which makes it easy to work with. When you receive JSON from an API, you need to parse it into Python data structures before you can extract specific values. The requests library makes this trivial with the .json() method.

import requests

url = "https://catfact.ninja/fact"
response = requests.get(url)

# Parse JSON response into a Python dictionary
data = response.json()

# Access specific fields
print(f"Cat fact: {data['fact']}")
print(f"Fact length: {data['length']}")

The .json() method converts the raw JSON text into a Python dictionary. Once parsed, you can access nested values using bracket notation or dot notation (for libraries that support it). This pattern—make request, parse JSON, extract values—is fundamental to every API integration you'll build.

Network requests fail all the time. Servers go down, endpoints change, connections timeout, and rate limits get exceeded. If you don't handle these failures gracefully, your program will crash the moment something goes wrong. Professional developers anticipate errors and write code that handles them elegantly.

The most common approach is using try-except blocks to catch exceptions. The requests library raises specific exceptions for different failure modes: requests.exceptions.ConnectionError for network problems, requests.exceptions.Timeout for slow responses, and requests.exceptions.HTTPError for bad status codes. You can catch all of them with requests.exceptions.RequestException.

import requests

url = "https://catfact.ninja/fact"

try:
    response = requests.get(url, timeout=5)
    response.raise_for_status()  # Raises HTTPError for bad status codes
    data = response.json()
    print(f"Cat fact: {data['fact']}")
except requests.exceptions.RequestException as e:
    print(f"Error making API request: {e}")

The timeout=5 parameter tells requests to wait a maximum of 5 seconds before giving up. The raise_for_status() method checks if the response has a successful status code (200-299) and raises an exception if it doesn't. This prevents you from trying to parse error pages as valid JSON.

Most APIs let you customize requests by passing parameters. These show up in the URL after a question mark, like ?key=value&another=value2. Parameters control pagination, filtering, sorting, and search. Instead of manually building URL strings (which gets messy and error-prone), the requests library lets you pass parameters as a Python dictionary.

Let's try an API that accepts parameters. The OpenWeatherMap API returns weather data for any city. You'll need to sign up for a free API key, but the process takes about 30 seconds. Once you have your key, you can request weather data like this:

import requests

url = "https://api.openweathermap.org/data/2.5/weather"

params = {
    "q": "London",
    "appid": "YOUR_API_KEY_HERE",
    "units": "metric"
}

response = requests.get(url, params=params)
data = response.json()

print(f"Temperature in London: {data['main']['temp']}°C")
print(f"Weather: {data['weather'][0]['description']}")

The params dictionary gets converted into the query string automatically. This is much cleaner than manually concatenating strings, and it handles URL encoding for you. If your parameter value has spaces or special characters, requests takes care of escaping them properly.

You've learned the fundamentals: making requests, parsing JSON, handling errors, and using parameters. Now let's combine everything into a complete program that integrates multiple APIs. This final project demonstrates how real applications work—chaining API calls, handling different response formats, and presenting data to users.

We'll build a simple program that fetches a random cat fact and checks the current weather, demonstrating how to work with two different APIs in one script. This pattern scales to any number of APIs—authentication services, payment processors, social media platforms, and more.

import requests

def get_cat_fact():
    """Fetch a random cat fact from the Cat Facts API."""
    try:
        response = requests.get("https://catfact.ninja/fact", timeout=5)
        response.raise_for_status()
        data = response.json()
        return data['fact']
    except requests.exceptions.RequestException as e:
        return f"Error fetching cat fact: {e}"

def get_weather(city, api_key):
    """Fetch current weather for a given city."""
    url = "https://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": city,
        "appid": api_key,
        "units": "metric"
    }
    
    try:
        response = requests.get(url, params=params, timeout=5)
        response.raise_for_status()
        data = response.json()
        
        temp = data['main']['temp']
        description = data['weather'][0]['description']
        return f"{temp}°C, {description}"
    except requests.exceptions.RequestException as e:
        return f"Error fetching weather: {e}"

# Main program
if __name__ == "__main__":
    print("=== Daily Info Dashboard ===\n")
    
    # Fetch cat fact
    cat_fact = get_cat_fact()
    print(f"🐱 Cat Fact of the Day:")
    print(f"{cat_fact}\n")
    
    # Fetch weather (replace with your actual API key)
    api_key = "YOUR_API_KEY_HERE"
    weather = get_weather("London", api_key)
    print(f"🌤️  Weather in London:")
    print(weather)

This program demonstrates professional patterns: separate functions for each API, consistent error handling, clear documentation, and a main block that orchestrates everything. As you build more complex applications, this structure scales well—you can add new API functions, implement caching, add retry logic, and more.

In this chapter, you made your first real API calls and learned the foundational patterns for working with web services in Python. These concepts—making requests, parsing JSON, handling errors, and using parameters—form the basis of every API integration you'll ever build.

Key Takeaways

• API calls use the same HTTP protocol whether made from a browser or Python.
• The requests library simplifies network calls to just a few lines of code.
• JSON is the standard format for API responses and maps directly to Python dictionaries.
• Always handle errors with try-except blocks and set timeouts on requests.
• Query parameters customize API calls and are passed as Python dictionaries.
• Real applications combine multiple APIs using the same fundamental patterns.

What's Next

You've successfully made your first API calls and handled real data from live servers. In the next chapter, we'll dive deeper into HTTP—the protocol that powers all web communication. You'll learn about request methods (GET, POST, PUT, DELETE), headers, authentication, and how to debug API interactions when things go wrong.

The skills you've learned in this chapter are immediately practical. You can already build scripts that check weather, fetch news headlines, validate email addresses, generate random data, and interact with thousands of free public APIs. As we continue through the book, you'll learn how to authenticate with secure APIs, handle rate limits, work with webhooks, and build production-ready integrations.