Project: Building an API-Integrated Data Tool in Python

Previously in this course, we covered Introduction to HTTP Requests and Parsing API Responses. In this lesson, we are finally bringing those skills together to build a functional project that performs a real-world API integration.

We aren't just printing raw JSON anymore. We are going to build a tool that takes your locally stored data—perhaps a list of tracked items or preferences—and enriches it with fresh, live information from the web.

The Power of Data Merging

Most backend applications rely on a "source of truth" pattern. You typically have your own database (or in our case, a JSON file) and external APIs that provide context.

For this project, we will build a "Weather Tracker" CLI. It will:

1. Load your list of "favorite cities" from a local JSON file.
2. Reach out to a public weather API to get the current temperature for those cities.
3. Merge the two sources and print a formatted report.

Worked Example: The Weather Enrichment Tool

We will use the requests library to fetch data. Ensure you have it installed in your virtual environment (as discussed in Virtual Environments).

First, assume you have a cities.json file in your directory:

JSON
["New York", "London", "Tokyo"]

Here is the implementation of our integration tool:

PYTHON
import requests
import json

def get_local_cities(filename):
    with open(filename, CE9178">'r') as f:
        return json.load(f)

def fetch_weather(city):
    # Using a placeholder URL for demonstration
    # In a real scenario, you'd use an API key and a provider like OpenWeatherMap
    url = f"https://api.example.com/weather?city={city}"
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException:
        return {"temp": "N/A", "error": "Could not fetch"}

def main():
    cities = get_local_cities(CE9178">'cities.json')
    report = []

    print("Fetching live data...")
    for city in cities:
        weather_data = fetch_weather(city)
        # Merging local and API data
        report.append({
            "city": city,
            "temperature": weather_data.get("temp")
        })

    print("\n--- Final Weather Report ---")
    for entry in report:
        print(f"City: {entry[CE9178">'city']} | Temp: {entry[CE9178">'temp']}°C")

if __name__ == "__main__":
    main()

Hands-on Exercise: Build Your Own Integration

Now it's your turn to extend the functionality. Using the logic above, modify your own version of the Project: The Data Collector CLI Tool for Python Beginners to:

1. Create a config.json that stores a list of stock symbols or product IDs.
2. Create a function that calls a public API (or a mock service) to get the "current price" for those symbols.
3. Print a report that shows your local ID alongside the live fetched price.

Common Pitfalls to Avoid

• Blocking Operations: Notice the timeout=5 in the request. Never perform network requests without a timeout; if the API server hangs, your entire CLI tool will freeze indefinitely.
• Assuming Success: APIs fail. If you expect a JSON response and the server returns a 500 error, your code will crash. Always use try/except blocks around network calls.
• Rate Limiting: If you are testing your loop against a real API, don't run it 100 times in a minute. Most public APIs will block your IP address if you hit them too frequently.

FAQ

Q: Does every API integration require an API Key? A: Most professional APIs do. You'll usually pass these via headers or URL parameters. We will cover managing these secrets securely in future lessons.

Q: Can I merge data from multiple APIs? A: Absolutely. The pattern remains the same: fetch from Source A, fetch from Source B, then combine the dictionaries in your local list.

Recap

In this lesson, we successfully combined local JSON storage with external API calls. This project represents a fundamental skill in backend engineering: API integration. You now understand how to orchestrate data movement between your local environment and the web, creating a cohesive, data-rich CLI output.

Up next: Introduction to Web Frameworks