Two programs need to swap data. One is written in Python, the other in something else entirely, running on a server across the world. They agree on a shared format, plain text that both sides can read, and that format is almost always JSON. It is the language the web uses to move data around, and Python speaks it with one small built-in module.

So this part answers two linked questions: how do you save your data in a format other programs understand, and how do you pull data from a service on the internet?

This part builds on files from Part 11, dictionaries from Part 8, and the package you installed in Part 14. You need Python 3 and about thirty minutes. The API section makes one real network call, so you need to be online for that piece.

What JSON is, and why it looks familiar

JSON stands for JavaScript Object Notation, but do not let the name distract you. It is just text arranged in a shape you already know, because a JSON object looks almost exactly like a Python dictionary and a JSON array looks like a Python list. Python converts between the two with the standard json module, and there are only two verbs to learn: dumps, which turns a Python value into JSON text, and loads, which turns JSON text back into Python.

import json

data = {'amount': 40, 'paid': True, 'note': None}
text = json.dumps(data)
print(text)

{"amount": 40, "paid": true, "note": null}

Read that output closely, because the small changes matter. Python’s True became true, and None became null. JSON has its own spelling for these, and all its text uses double quotes, never single. You do not do this conversion by hand; json.dumps handles it. But knowing it happens explains a lot of surprises later.

Table 1. How Python values map to JSON when you save them.

Saving the tracker as JSON

In Part 11 you saved expenses as comma separated lines and split them back by hand. JSON does that work for you and survives nested data without any parsing. Use json.dump to write straight to a file, and json.load to read it back, both keeping your list of dictionaries intact:

import json

expenses = [
    {'amount': 120.5, 'category': 'food'},
    {'amount': 40, 'category': 'travel'},
]

with open('expenses.json', 'w') as f:
    json.dump(expenses, f, indent=2)

with open('expenses.json') as f:
    loaded = json.load(f)
print(loaded)

[{'amount': 120.5, 'category': 'food'}, {'amount': 40, 'category': 'travel'}]

The indent=2 tells Python to lay the file out on multiple lines so a human can read it. Open expenses.json in your editor and you see a tidy, structured file. Unlike the hand split text from Part 11, this round trips perfectly: what you save is exactly what you load, types and all, with no manual conversion in the middle.

TypeError: Object of type Expense is not
JSON serializable

Calling a web API

An API is a program’s doorway: a URL you request, that hands back data instead of a web page. Most return JSON. To call one you use the requests package, the same kind you installed in Part 14. Install it into your environment with pip install requests, then ask a free currency service for today’s dollar to rupee rate:

import requests

url = 'https://api.frankfurter.dev/v1/latest'
params = {'base': 'USD', 'symbols': 'INR'}
response = requests.get(url, params=params, timeout=10)
response.raise_for_status()
data = response.json()
print(data['rates']['INR'])

88.42

Your number will differ, because exchange rates change every day; that is the point of asking a live service instead of hard coding a value. Walk the code: requests.get fetches the URL with your parameters, raise_for_status turns a failed request into a clear error instead of silent bad data, and response.json() parses the returned JSON into an ordinary Python dictionary you index like any other. The timeout stops your program hanging forever if the server never answers.

Putting them together in the tracker

Now the tracker can save its data as JSON and show the total in another currency using a live rate. This ties Part 12’s error handling to a real world truth: the network fails sometimes, and a program that assumes it never will is a program that crashes on a train.

import requests

def usd_to_inr(amount):
    url = 'https://api.frankfurter.dev/v1/latest'
    params = {'base': 'USD', 'symbols': 'INR'}
    try:
        r = requests.get(url, params=params, timeout=10)
        r.raise_for_status()
        rate = r.json()['rates']['INR']
        return amount * rate
    except requests.RequestException:
        return None

total = 160.5
converted = usd_to_inr(total)
if converted is None:
    print('rate unavailable, showing USD only')
else:
    print(f'{converted:,.2f} INR')

14,191.41 INR

Again, your figure will differ with the day’s rate. What matters is the shape: the call is wrapped so a network failure returns None instead of crashing, and the caller checks for that before printing. I will say plainly what many tutorials leave out: a bare requests.get with no timeout and no error handling is fine in a demo and wrong in anything real, because the internet is not reliable and your program has to expect that.

{
  "city": "Pune",
  "temp": 31
}

import json

data = {'city': 'Pune', 'temp': 31}
print(json.dumps(data, indent=2))

JSON and API questions that come up

What is the difference between dumps and dump? json.dumps returns a string; json.dump writes straight to a file. The same pairing holds for loads, which reads a string, and load, which reads a file. The extra s is for string.

Do I need a key or an account to call an API? Some APIs need a key, many public ones do not. The currency service here needs nothing. When an API does need a key, you pass it along with the request, and you keep it out of your code.

Why did my JSON keys come back as strings when they were numbers? JSON object keys are always text. If you store a number as a key, it returns as a string, which trips people converting data back.

Is requests part of Python? No, it is a package you install with pip, which is why Part 14 came first. The standard library has urllib, but requests is far friendlier and what most code uses.

What if the API is down or I am offline? The request raises an error. Wrap the call in try and except as shown, and decide what your program does when the data does not arrive.

Digging into nested JSON

Real API responses are rarely flat. They nest objects inside objects, and lists inside those, and getting a value out means stepping down the layers with the same indexing you already use for dictionaries and lists. The currency response is a small example: the rate you want sits two levels in, under the rates key and then the currency code.

data = {
    'base': 'USD',
    'date': '2026-07-03',
    'rates': {'INR': 88.42, 'EUR': 0.92},
}
print(data['rates']['INR'])
print(data['rates']['EUR'])

88.42
0.92

Each square bracket steps one level down. The first reaches the rates object, the second picks a currency inside it. When a response hands you a list instead, you reach items by position, so something like data['results'][0]['rate'] takes the first record and then its rate. Mixing key lookups and index numbers as you descend is completely normal, and matching each bracket to a layer in the printed response is how you keep from getting lost.

One catch: asking for a key that is not there raises a KeyError and stops the program. When you are not certain a field exists in a response, reach for .get, which returns None, or a default you choose, instead of crashing:

print(data.get('rates', {}).get('GBP'))

None

The currency has no GBP entry, so instead of a crash you get None, which your code can check for. This matters with real APIs, where a field you expect is sometimes simply absent.

References

The json module (official docs) · requests documentation · Frankfurter currency API