10 APIs Gratuitas para Python — Uso Comercial, Código de Produção e Guia de Segurança

Com APIs externas, desenvolvedores Python podem implementar recuperação de dados, informações financeiras e processamento de imagens sem construir tudo do zero. Porém, “gratuito para usar” e “seguro para produção” são coisas completamente diferentes.

Este artigo apresenta 10 APIs gratuitas e práticas para Python com código pronto para produção, detalhes de Rate Limit e padrões de design seguro. Além de uma simples lista de APIs, cobrimos a filosofia de design que profissionais usam ao trabalhar com APIs externas.

Nível alvo: Iniciante a intermediário (capaz de usar requests). Pré-requisito:

pip install requests

Para gerenciamento seguro de chaves de API, consulte também “10 Padrões de Implementação de Segurança em Python.”

Modelo Básico para Chamadas de API

Antes de mergulhar nas APIs individuais, vamos estabelecer o modelo base que toda chamada de API deve seguir. Em produção, estes quatro pontos são o padrão mínimo:

• Definir timeout — evite que seu programa espere indefinidamente
• Verificar códigos de status — trate respostas diferentes de 200 corretamente
• Tratar exceções — lide com falhas de rede e timeouts
• Não assumir JSON — evite travamentos quando a resposta for HTML ou texto

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")

Tabela Comparativa de APIs Gratuitas

① Open-Meteo — API de Clima sem Chave

Open-Meteo é uma API de dados climáticos completamente gratuita, sem chave de API. Oferece clima atual, temperatura, velocidade do vento, precipitação e previsões de até 16 dias. Uso comercial permitido, sendo a escolha ideal para ferramentas relacionadas ao clima.

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")

A maior vantagem é acesso instantâneo aos dados sem autenticação. Sem necessidade de registro de chave de API ou criação de conta. Altere latitude/longitude e obtenha dados climáticos de qualquer lugar do mundo.

② ExchangeRate API — Taxas de Câmbio

ExchangeRate API fornece taxas de câmbio gratuitas para moedas principais. Útil para ferramentas de conversão de moeda, sites de comparação de preços e dashboards financeiros. Sem chave de API necessária, com 1.500 requisições por dia.

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")

Uma consideração crítica com dados financeiros é a frequência de atualização. Esta API atualiza aproximadamente uma vez por dia, portanto não é adequada para negociação em tempo real. Oferece precisão suficiente para conversão aproximada de moeda e referências de preço diárias.

③ CoinGecko API — Preços de Criptomoedas

CoinGecko fornece preços de criptomoedas, capitalização de mercado, volumes de negociação e rankings. O plano gratuito é surpreendentemente poderoso e amplamente usado para desenvolvimento de ferramentas relacionadas a criptomoedas.

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}%)")

O Rate Limit do CoinGecko no plano gratuito é aproximadamente 10–30 requisições por minuto. Como preços de criptomoedas são voláteis, cache é essencial. Busque dados a cada minuto, armazene localmente e sirva do cache.

④ JSONPlaceholder — O Padrão para Prática de API

JSONPlaceholder é uma API mock projetada para aprendizado e teste de APIs REST. Fornece dados simulados para usuários, posts, comentários e álbuns, amplamente usada para prototipagem de desenvolvimento de API e testes de 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}")

A maior vantagem é suporte a todos os métodos HTTP: GET, POST, PUT, PATCH, DELETE. Requisições POST e DELETE não modificam dados reais — as respostas são simuladas, permitindo experimentar com segurança. Ideal para integração de novos engenheiros e testes de clientes de API.

⑤ REST Countries — Informações de Países

REST Countries fornece informações básicas sobre todos os países do mundo — população, área, capital, bandeira, moeda, idiomas e região — tudo em formato JSON. Ótimo para ferramentas de educação geográfica, dashboards de estatísticas e aplicações internacionalizadas.

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']}")

Esta API é ideal para cache pois dados de países raramente mudam. Busque todos os dados uma vez e armazene localmente — não é necessário chamar a API novamente. Carregar todos os dados na memória na inicialização é a abordagem mais eficiente.

⑥ The Cat API — Imagens Aleatórias de Gatos

The Cat API retorna imagens aleatórias de gatos. Embora pareça divertido, é genuinamente útil em produção para teste de exibição de imagens em UI, geração de placeholders dinâmicos e teste de clientes de 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']})")

Recursos básicos funcionam sem chave de API, mas registrar uma chave gratuita aumenta os limites de taxa e desbloqueia filtros de raça e favoritos.

⑦ IP-API — Geolocalização por IP

IP-API retorna dados de geolocalização a partir de endereços IP — país, região, cidade, provedor e fuso horário. Usado para análise de acesso, exibição de conteúdo por região e monitoramento de segurança.

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']}")

O limite de taxa é 45 requisições por minuto. Para consultas em lote de IPs, use o endpoint http://ip-api.com/batch para melhor eficiência.

⑧ Advice Slip API — Frases Aleatórias

Advice Slip API retorna conselhos e frases aleatórias em inglês. Útil para exibição de testes de UI, recursos de mensagem diária e enfeites de chatbot.

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}")

Esta API possui um design de endpoint minimalista — apenas /advice (aleatório) e /advice/{id} (por ID). Um intervalo de 2 segundos entre chamadas consecutivas se aplica.

⑨ PokeAPI — Ideal para Aprender Dados Estruturados

PokeAPI fornece nomes, tipos, estatísticas e imagens de Pokémon. Além de dados de jogos, sua estrutura a torna excelente para aprender processamento de JSON aninhado, paginação e manipulação de dados relacionais — padrões que você encontrará em toda API de produção.

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']}")

As respostas do PokeAPI são profundamente aninhadas, exigindo padrões de acesso como data["types"][0]["type"]["name"]. Isso é comum em APIs de produção (Stripe, Twilio, AWS SDK), então praticar aqui torna a integração com APIs reais mais suave.

⑩ Numbers API — Curiosidades Numéricas

Numbers API retorna curiosidades e fatos divertidos sobre qualquer número. Útil para sites educacionais, ferramentas de quiz e enfeites de UI com conteúdo diário.

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 ...

Os tipos incluem trivia (padrão), math, date e year. Por exemplo, http://numbersapi.com/3/14/date?json retorna curiosidades sobre 14 de março.

Rate Limits e Estratégia de Cache

A armadilha mais perigosa com APIs gratuitas é exceder os limites de taxa. Serviços gratuitos têm limites rígidos, e violações resultam em bloqueios de IP que podem durar horas ou dias.

Padrões típicos de limite de taxa:

A solução é cache. Armazene respostas da API localmente e sirva do cache dentro de uma janela TTL.

import requests
import time
import json
import os

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

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

Padrões Essenciais de Design Seguro

Código de produção que usa APIs externas requer estes cinco padrões de design:

Um padrão de produção combinado:

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

Lembre-se deste princípio de produção: APIs externas são não confiáveis por padrão. Indisponibilidades, mudanças de especificação, picos de latência, alterações de limite — estes não são cenários “podem acontecer”, são “vão acontecer”. Profissionais projetam assumindo que APIs externas não podem ser confiadas.

Para mais sobre design seguro, consulte “10 Padrões de Implementação de Segurança em Python.”

Erros Comuns e Termos de Serviço

Conheça os padrões de falha que iniciantes frequentemente encontram:

Sempre verifique os Termos de Serviço. Mesmo APIs gratuitas podem ter restrições:

• Sem uso comercial — apenas uso pessoal
• Atribuição obrigatória — obrigação de exibir “Powered by ○○”
• Sem redistribuição — não pode republicar dados brutos em outro serviço
• Restrições HTTPS — plano gratuito apenas HTTP (IP-API, Numbers API)

Design Profissional — Provider Abstraction

Desenvolvedores experientes sempre pensam em APIs externas desta forma:

• APIs gratuitas são para prototipagem e validação
• Planeje migração para plano pago ou substituição self-hosted em produção
• Projete para evitar dependência excessiva de qualquer provedor único

Isso é alcançado através de Provider Abstraction — encapsulando chamadas de API atrás de uma interface para que provedores possam ser trocados sem alterar o código da aplicação.

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")

Com este design, trocar provedores de API requer alterar apenas uma classe. Não é necessário reescrever toda a aplicação. Durante testes, você também pode trocar por um provedor mock.

Perguntas Frequentes

P: Qual a diferença entre APIs com e sem chave?

Chaves de API identificam usuários. APIs sem chave são convenientes mas tendem a ter limites de taxa mais rígidos baseados em IP. APIs com chave podem gerenciar limites por usuário e tipicamente permitem mais requisições.

P: Posso construir um serviço público usando APIs gratuitas?

Depende dos Termos de Serviço. Open-Meteo e REST Countries permitem uso comercial, mas o plano gratuito do IP-API é apenas não comercial. Sempre verifique o ToS de cada API antes de publicar.

P: E se uma API cair de repente?

É exatamente por isso que o design de fallback importa. Mantenha dados recentes em cache para poder servi-los durante indisponibilidades. Para indisponibilidade prolongada, use Provider Abstraction para alternar para uma API alternativa.

P: O que significa 429 Too Many Requests?

Você excedeu o limite de taxa. Verifique o cabeçalho de resposta Retry-After e aguarde os segundos especificados antes de tentar novamente. Se estiver consistentemente recebendo 429, implemente cache ou aumente os intervalos entre requisições.

Conclusão

APIs gratuitas permitem que desenvolvedores Python implementem clima, câmbio, criptomoedas, imagens e inúmeras outras funcionalidades em tempo recorde. Mas o que realmente importa não é quais APIs você escolhe — é como você as usa.

1. Sempre implemente timeout e tratamento de erros
2. Verifique os Rate Limits e mantenha-se dentro deles usando cache
3. Leia os Termos de Serviço antes de usar qualquer API
4. Gerencie dependências com Provider Abstraction
5. Projete assumindo que APIs externas são não confiáveis

APIs são poderosas, mas dependência excessiva quebra coisas. Usadas com sabedoria, podem acelerar drasticamente sua velocidade de desenvolvimento. Essa é a essência da integração com APIs externas.