10 APIs Gratuites pour Python — Usage Commercial, Code de Production et Guide de Sécurité

Avec les APIs externes, les développeurs Python peuvent implémenter la récupération de données, les informations financières et le traitement d’images sans tout construire soi-même. Cependant, « gratuit à utiliser » et « sûr en production » sont deux choses entièrement différentes.

Cet article présente 10 APIs gratuites et pratiques pour Python avec du code prêt pour la production, des détails sur les Rate Limits et des patterns de conception sécurisée. Au-delà d’une simple liste d’APIs, nous couvrons la philosophie de conception que les professionnels utilisent avec les APIs externes.

Niveau cible : débutant à intermédiaire (capable d’utiliser requests). Prérequis :

pip install requests

Pour la gestion sécurisée des clés API, voir aussi « 10 Patterns de Sécurité Python ».

Modèle de Base pour les Appels API

Avant de plonger dans les APIs individuelles, établissons le modèle de base que tout appel API doit suivre. En production, ces quatre points sont le minimum requis :

• Définir un timeout — éviter que votre programme attende indéfiniment
• Vérifier les codes de statut — gérer correctement les réponses non-200
• Gérer les exceptions — faire face aux pannes réseau et timeouts
• Ne pas supposer du JSON — éviter les plantages quand la réponse est HTML ou texte

import requests

url = "https://api.example.com/data"

try:
    response = requests.get(url, timeout=5)
    response.raise_for_status()
    data = response.json()
    print(data)
except requests.exceptions.Timeout:
    print("Timeout: server not responding")
except requests.exceptions.HTTPError as e:
    print(f"HTTP error: {e.response.status_code}")
except requests.exceptions.RequestException as e:
    print(f"Request error: {e}")
except ValueError:
    print("JSON decode error: response is not JSON")

Tableau Comparatif des APIs Gratuites

① Open-Meteo — API Météo sans Clé

Open-Meteo est une API météo entièrement gratuite, sans clé API. Elle fournit la météo actuelle, température, vitesse du vent, précipitations et prévisions jusqu’à 16 jours. L’usage commercial est autorisé, ce qui en fait le choix idéal pour les outils météo.

import requests

url = "https://api.open-meteo.com/v1/forecast"
params = {
    "latitude": 35.6762,
    "longitude": 139.6503,
    "current_weather": True
}

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

weather = data["current_weather"]
print(f"Temp: {weather['temperature']}°C")
print(f"Wind: {weather['windspeed']} km/h")

Le plus grand avantage est l’accès instantané aux données sans authentification. Pas d’inscription de clé API ni de création de compte. Changez latitude/longitude et vous obtenez les données météo de n’importe où dans le monde.

② ExchangeRate API — Taux de Change

ExchangeRate API fournit des taux de change gratuits pour les principales devises. Utile pour les outils de conversion, sites de comparaison de prix et tableaux de bord financiers. Pas de clé API requise, 1 500 requêtes par jour.

import requests

url = "https://open.er-api.com/v6/latest/USD"
response = requests.get(url, timeout=5)
data = response.json()

jpy_rate = data["rates"]["JPY"]
print(f"1 USD = {jpy_rate} JPY")

# Currency conversion example
usd_amount = 100
jpy_amount = usd_amount * jpy_rate
print(f"{usd_amount} USD = {jpy_amount:.0f} JPY")

Un point critique avec les données financières est la fréquence de mise à jour. Cette API se met à jour environ une fois par jour, donc inadaptée au trading en temps réel. Elle offre une précision suffisante pour la conversion approximative et les références de prix quotidiennes.

③ CoinGecko API — Prix des Cryptomonnaies

CoinGecko fournit les prix des cryptomonnaies, capitalisations boursières, volumes de trading et classements. Le plan gratuit est étonnamment puissant et largement utilisé pour le développement d’outils crypto.

import requests

url = "https://api.coingecko.com/api/v3/simple/price"
params = {
    "ids": "bitcoin,ethereum",
    "vs_currencies": "usd,eur",
    "include_24hr_change": "true"
}

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

btc = data["bitcoin"]
print(f"BTC: ${btc['usd']:,.0f} (24h: {btc['usd_24h_change']:.1f}%)")

Le Rate Limit de CoinGecko sur le plan gratuit est d’environ 10–30 requêtes par minute. Les prix crypto étant volatils, le cache est essentiel. Récupérez les données chaque minute, stockez localement et servez depuis le cache.

④ JSONPlaceholder — La Référence pour la Pratique API

JSONPlaceholder est une API mock conçue pour l’apprentissage et les tests REST. Elle fournit des données simulées pour utilisateurs, posts, commentaires et albums, largement utilisée pour le prototypage et les tests frontend.

import requests

# Get posts
url = "https://jsonplaceholder.typicode.com/posts"
params = {"_limit": 3}
response = requests.get(url, params=params, timeout=5)
posts = response.json()

for post in posts:
    print(f"[{post['id']}] {post['title']}")

# Practice POST requests
new_post = {"title": "Test", "body": "Hello", "userId": 1}
res = requests.post(url, json=new_post, timeout=5)
print(f"Created: status={res.status_code}")

Le plus grand avantage est le support de toutes les méthodes HTTP : GET, POST, PUT, PATCH, DELETE. Les requêtes POST et DELETE ne modifient pas les données réelles — les réponses sont simulées, permettant d’expérimenter en toute sécurité. Idéal pour l’onboarding des développeurs et les tests de clients API.

⑤ REST Countries — Informations sur les Pays

REST Countries fournit les informations de base sur chaque pays du monde — population, superficie, capitale, drapeau, devise, langues et région — le tout en JSON. Idéal pour les outils de géographie, tableaux de bord statistiques et applications internationalisées.

import requests

url = "https://restcountries.com/v3.1/name/japan"
response = requests.get(url, timeout=5)
data = response.json()[0]

print(f"Country: {data['name']['common']}")
print(f"Capital: {data['capital'][0]}")
print(f"Population: {data['population']:,}")
print(f"Region: {data['region']}")
print(f"Flag: {data['flag']}")

Cette API est idéale pour le cache car les données pays changent rarement. Récupérez toutes les données une fois et stockez localement — pas besoin de rappeler l’API. Charger toutes les données en mémoire au démarrage est l’approche la plus efficace.

⑥ The Cat API — Images de Chats Aléatoires

The Cat API retourne des images de chats aléatoires. Bien que ludique, elle est réellement utile en production pour les tests d’affichage d’images UI, la génération de placeholders dynamiques et les tests de clients API.

import requests

url = "https://api.thecatapi.com/v1/images/search"
params = {"limit": 3}
response = requests.get(url, params=params, timeout=5)
images = response.json()

for img in images:
    print(f"URL: {img['url']} (size: {img['width']}x{img['height']})")

Les fonctionnalités de base fonctionnent sans clé API, mais l’inscription pour une clé gratuite augmente les limites et débloque les filtres par race et favoris.

⑦ IP-API — Géolocalisation par IP

IP-API retourne les données de géolocalisation à partir des adresses IP — pays, région, ville, FAI et fuseau horaire. Utilisé pour l’analytique d’accès, l’affichage de contenu par région et la surveillance de sécurité.

import requests

url = "http://ip-api.com/json/"
response = requests.get(url, timeout=5)
data = response.json()

print(f"Country: {data['country']}")
print(f"Region: {data['regionName']}")
print(f"City: {data['city']}")
print(f"ISP: {data['isp']}")
print(f"Timezone: {data['timezone']}")

La limite est de 45 requêtes par minute. Pour les lookups IP en lot, utilisez l’endpoint http://ip-api.com/batch pour plus d’efficacité.

⑧ Advice Slip API — Citations Aléatoires

Advice Slip API retourne des conseils et citations aléatoires en anglais. Utile pour les affichages de test UI, les messages quotidiens et les embellissements de chatbots.

import requests

url = "https://api.adviceslip.com/advice"
response = requests.get(url, timeout=5)
data = response.json()

advice = data["slip"]["advice"]
print(f"Today's advice: {advice}")

Cette API se caractérise par un design d’endpoint minimaliste — juste /advice (aléatoire) et /advice/{id} (par ID). Une limite d’intervalle de 2 secondes s’applique entre les appels consécutifs.

⑨ PokeAPI — Idéal pour Apprendre les Données Structurées

PokeAPI fournit les noms, types, stats et images des Pokémon. Au-delà des données de jeu, sa structure en fait un excellent outil pour apprendre le traitement JSON imbriqué, la pagination et la gestion de données relationnelles — des patterns que vous rencontrerez dans toute API de production.

import requests

url = "https://pokeapi.co/api/v2/pokemon/pikachu"
response = requests.get(url, timeout=5)
data = response.json()

print(f"Name: {data['name']}")
print(f"Type: {data['types'][0]['type']['name']}")
print(f"HP: {data['stats'][0]['base_stat']}")
print(f"Image: {data['sprites']['front_default']}")

Les réponses PokeAPI sont profondément imbriquées, nécessitant des patterns d’accès comme data["types"][0]["type"]["name"]. C’est courant dans les APIs de production (Stripe, Twilio, AWS SDK), donc s’entraîner ici facilite l’intégration API réelle.

⑩ Numbers API — Anecdotes sur les Nombres

Numbers API retourne des anecdotes et faits amusants sur n’importe quel nombre. Utile pour les sites éducatifs, outils de quiz et embellissement UI avec contenu quotidien.

import requests

number = 42
url = f"http://numbersapi.com/{number}?json"
response = requests.get(url, timeout=5)
data = response.json()

print(f"{number}: {data['text']}")
# e.g.: 42: 42 is the answer to the Ultimate Question ...

Les types incluent trivia (par défaut), math, date et year. Par exemple, http://numbersapi.com/3/14/date?json retourne une anecdote sur le 14 mars.

Rate Limits et Stratégie de Cache

Le piège le plus dangereux avec les APIs gratuites est de dépasser les rate limits. Les services gratuits ont des limites strictes, et les violations entraînent des bannissements IP pouvant durer des heures ou des jours.

Patterns typiques de rate limit :

La solution est le cache. Stockez les réponses API localement et servez depuis le cache dans une fenêtre TTL.

import requests
import time
import json
import os

CACHE_FILE = "cache.json"
CACHE_TTL = 300  # 5 minutes

def get_with_cache(url):
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE) as f:
            cache = json.load(f)
        if url in cache and time.time() - cache[url]["time"] < CACHE_TTL:
            return cache[url]["data"]

    response = requests.get(url, timeout=5)
    data = response.json()

    cache = {}
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE) as f:
            cache = json.load(f)
    cache[url] = {"data": data, "time": time.time()}
    with open(CACHE_FILE, "w") as f:
        json.dump(cache, f)

    return data

Patterns Essentiels de Conception Sécurisée

Le code de production utilisant des APIs externes requiert ces cinq patterns de conception :

Un pattern de production combiné :

import requests
import time

def safe_api_call(url, max_retries=3, delay=1):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, timeout=5)
            if response.status_code == 429:  # Rate Limit
                wait = int(response.headers.get("Retry-After", delay * 2))
                time.sleep(wait)
                continue
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException:
            if attempt < max_retries - 1:
                time.sleep(delay * (attempt + 1))
                continue
            return None  # fallback
    return None

Retenez ce principe de production : les APIs externes sont peu fiables par défaut. Pannes, changements de spec, pics de latence, modifications de limites — ce ne sont pas des scénarios « pourraient arriver », ils « arriveront ». Les professionnels conçoivent en supposant que les APIs externes ne peuvent pas être fiables.

Pour plus sur la conception sécurisée, voir « 10 Patterns de Sécurité Python ».

Erreurs Courantes et Conditions d’Utilisation

Connaissez les patterns d’échec que les débutants rencontrent souvent :

Vérifiez toujours les Conditions d’Utilisation. Même les APIs gratuites peuvent avoir des restrictions :

• Pas d’usage commercial — usage personnel uniquement
• Attribution requise — obligation d’affichage « Propulsé par ○○ »
• Pas de redistribution — impossible de republier les données brutes sur un autre service
• Restrictions HTTPS — tier gratuit HTTP uniquement (IP-API, Numbers API)

Conception Professionnelle — Provider Abstraction

Les développeurs expérimentés pensent toujours aux APIs externes ainsi :

• Les APIs gratuites servent au prototypage et à la validation
• Prévoyez la migration vers un tier payant ou un remplacement self-hosted en production
• Concevez pour éviter la sur-dépendance à un seul fournisseur

Cela s’obtient via l’Abstraction de Fournisseur — encapsuler les appels API derrière une interface pour pouvoir changer de fournisseur sans modifier le code applicatif.

class WeatherProvider:
    def get_temperature(self, lat, lon):
        raise NotImplementedError

class OpenMeteoProvider(WeatherProvider):
    def get_temperature(self, lat, lon):
        url = f"https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current_weather=true"
        data = requests.get(url, timeout=5).json()
        return data["current_weather"]["temperature"]

class PaidWeatherProvider(WeatherProvider):
    def get_temperature(self, lat, lon):
        # Swap to paid API by changing just this class
        pass

# Usage
weather = OpenMeteoProvider()
temp = weather.get_temperature(35.67, 139.65)
print(f"Temperature: {temp}°C")

Avec ce design, changer de fournisseur API ne nécessite de modifier qu’une seule classe. Pas besoin de réécrire toute l’application. En test, vous pouvez aussi injecter un provider mock.

Questions Fréquentes

Q : Quelle est la différence entre les APIs avec et sans clé ?

Les clés API identifient les utilisateurs. Les APIs sans clé sont pratiques mais ont tendance à avoir des limites plus strictes basées sur l’IP. Les APIs avec clé peuvent gérer les limites par utilisateur et permettent généralement plus de requêtes.

Q : Puis-je créer un service public avec des APIs gratuites ?

Cela dépend des Conditions d’Utilisation. Open-Meteo et REST Countries autorisent l’usage commercial, mais le tier gratuit d’IP-API est non-commercial uniquement. Vérifiez toujours les CGU de chaque API avant publication.

Q : Que faire si une API tombe soudainement ?

C’est exactement pourquoi le design fallback compte. Gardez les données récentes en cache pour les servir pendant les pannes. Pour les indisponibilités prolongées, utilisez l’Abstraction de Fournisseur pour basculer vers une API alternative.

Q : Que signifie 429 Too Many Requests ?

Vous avez dépassé le rate limit. Vérifiez l’en-tête de réponse Retry-After et attendez le nombre de secondes indiqué avant de réessayer. Si vous rencontrez régulièrement des 429, implémentez le cache ou augmentez les intervalles entre requêtes.

Conclusion

Les APIs gratuites permettent aux développeurs Python d’implémenter météo, devises, crypto, images et bien d’autres fonctionnalités en un temps record. Mais ce qui compte vraiment n’est pas quelles APIs vous choisissez — c’est comment vous les utilisez.

1. Toujours implémenter timeout et gestion d’erreurs
2. Vérifier les Rate Limits et rester dans les limites grâce au cache
3. Lire les Conditions d’Utilisation avant d’utiliser toute API
4. Gérer les dépendances avec l’Abstraction de Fournisseur
5. Concevoir en supposant que les APIs externes sont peu fiables

Les APIs sont puissantes, mais la sur-dépendance casse les choses. Utilisées avec sagesse, elles peuvent accélérer considérablement votre développement. C’est l’essence de l’intégration d’APIs externes.