Introduction to Web APIs

• API: Application Programming Interface
• Analogy: A menu in a restaurant, defining operations
• Web API: An API accessed over the web (HTTP)
• REST (REpresentational State Transfer) is a popular style for designing networked applications
• We use REST APIs to fetch data programmatically

REST Request/Response Flow

Here's what happens when you call an API:

How REST APIs Work

• Resources: Data entities (e.g., users, posts)
• Endpoints: URLs that represent resources
  • e.g., https://api.example.com/users
• HTTP Methods (Verbs): Actions on resources

Our focus will be on GET for data retrieval.

Making Your First API Request

We use the requests library in Python:

import requests

# Define the API endpoint URL
url = "https://jsonplaceholder.typicode.com/posts/1"

# Send a GET request
response = requests.get(url)

# The response object contains server's response
print(response.status_code)  # e.g., 200
print(response.json())       # The data in JSON format

Understanding the Response

HTTP Status Codes:

Response Body: The actual data, often in JSON format (key-value pairs).

Exercise 1: Simple GET Request

Goal: Fetch a list of users from a public API

API Endpoint: https://jsonplaceholder.typicode.com/users

1. Write a Python script using requests
2. Make a GET request to the endpoint
3. Check if the request was successful (status code 200)
4. Print the name of the first user in the list

Working with API Parameters

/users/1

/posts?userId=1

Passing query parameters with requests:

params = {'userId': 1}
response = requests.get('.../posts', params=params)
print(response.url)  # See the final URL

Exercise 2: Filtering API Results

Goal: Fetch comments for a specific post

API Endpoint: https://jsonplaceholder.typicode.com/comments

1. Use query parameters to get comments for postId=1
2. Write a Python script to perform this request
3. Print the number of comments received
4. Print the email of the first commenter

Handling Authentication

Why? To identify the client, for security, and for rate limiting.

Common methods:

• API Keys: A unique string sent with each request
• Bearer Tokens (OAuth): For delegated access

Sending a key in the headers:

headers = {'Authorization': 'Bearer YOUR_API_KEY'}
response = requests.get(url, headers=headers)

Exercise 3: Error Handling

Goal: Write robust code that handles potential API errors

1. Request a non-existent post (e.g., /posts/99999)
2. Check the status_code to see if it's 200
3. If not 200, print an informative error message
4. Wrap the request in a try...except block to catch network errors

try:
    response = requests.get(url, timeout=5)
    response.raise_for_status()  # Raises exception for bad status
except requests.RequestException as e:
    print(f"Request failed: {e}")

Integrating with Orange Data Mining

Goal: Convert API data into an Orange Data Table

from Orange.data import Table, Domain, StringVariable
import requests

# 1. Fetch data from API
users_data = requests.get(
    'https://jsonplaceholder.typicode.com/users'
).json()

# 2. Define the domain (the columns)
domain = Domain([
    StringVariable('name'),
    StringVariable('email'),
    StringVariable('city')
])

# 3. Create the data table
data = [[u['name'], u['email'], u['address']['city']]
        for u in users_data]
out_data = Table.from_list(domain, data)

Final Exercise: World Countries Data

API: RestCountries - https://restcountries.com/v3.1/all