Como economizar cota de API e acelerar sua aplicação usando Redis

Se você utiliza APIs externas em suas aplicações, provavelmente já se deparou com dois desafios comuns: latência de rede e limites de cota (rate limits).

No caso da Feriados API, muitos desenvolvedores precisam consultar os feriados nacionais de um determinado ano. A questão é: os feriados de 2026 não vão mudar amanhã, nem semana que vem. Então, por que “gastar” uma requisição da sua cota e esperar a resposta da rede toda vez que seu usuário acessa o sistema?

Neste artigo, vamos mostrar como implementar um sistema de cache simples e eficiente usando Redis e Python. Essa técnica permite que você utilize o plano Free de forma muito mais inteligente, economizando requisições para quando realmente importam.

O Problema: Requisições Repetidas

Imagine que sua aplicação tem um dashboard que mostra se “hoje é feriado”. Se você tiver 1.000 usuários acessando esse dashboard por dia, e para cada acesso você fizer uma chamada à API:

• →Você consumirá 1.000 requisições da sua cota instantaneamente.
• →Sua aplicação ficará mais lenta, dependendo da resposta da API externa.

A Solução: Cache com Redis

O Redis é um banco de dados em memória extremamente rápido, perfeito para funcionar como cache. A lógica é simples:

1. Antes de chamar a API, perguntamos ao Redis: “Você já tem os feriados de 2026?”
2. Se sim (Cache Hit): Pegamos os dados do Redis instantaneamente. Custo de API = 0.
3. Se não (Cache Miss): Chamamos a API, pegamos os dados, salvamos no Redis e retornamos ao usuário.

Mão na Massa

Pré-requisitos

Você precisará de Python instalado e um servidor Redis rodando (pode ser local ou na nuvem). Instale as bibliotecas necessárias:

pip install requests redis

O Código

Abaixo, um exemplo prático de uma função get_feriados robusta, que implementa o padrão Cache-Aside:

import json
import requests
import redis
from datetime import timedelta

# -- Configurações --
# Substitua pela sua chave real obtida no dashboard
API_KEY = "SEU_TOKEN_AQUI" 
BASE_URL = "https://feriadosapi.com/api/v1"

# Configuração do Redis (ajuste host/port conforme seu ambiente)
REDIS_HOST = "localhost"
REDIS_PORT = 6379

# Tempo de vida do cache (TTL). 
# Como feriados raramente mudam, podemos usar um tempo longo.
CACHE_TTL = timedelta(days=30) 

# Conexão com o Redis
r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, db=0, decode_responses=True)

def get_feriados(ano):
    """
    Busca feriados nacionais para um ano específico.
    Utiliza cache para evitar chamadas repetidas à API.
    """
    # Criamos uma chave única para esse dado
    cache_key = f"feriados_nacionais_{ano}"
    
    # 1. TENTA PEGAR DO CACHE
    print(f"🔍 Verificando cache para o ano {ano}...")
    cached_data = r.get(cache_key)
    
    if cached_data:
        print("✅ Cache HIT! Retornando dados da memória.")
        return json.loads(cached_data)
    
    # 2. SE NÃO ESTIVER NO CACHE, CONSOME A API
    print("🌍 Cache MISS. Fazendo requisição à API externa...")
    headers = {
        "Authorization": f"Bearer {API_KEY}"
    }
    
    try:
        response = requests.get(
            f"{BASE_URL}/feriados/nacionais",
            params={"ano": ano},
            headers=headers
        )
        response.raise_for_status()
        
        data = response.json()
        
        if 'feriados' in data:
            feriados_list = data['feriados']
            
            # 3. SALVA NO CACHE PARA O FUTURO
            r.setex(
                name=cache_key,
                time=CACHE_TTL,
                value=json.dumps(feriados_list, ensure_ascii=False)
            )
            print("💾 Dados salvos no cache com sucesso.")
            
            return feriados_list
        else:
            print("⚠️ Resposta inesperada da API.")
            return []
            
    except requests.exceptions.RequestException as e:
        print(f"❌ Erro ao conectar na API: {e}")
        return []

Testando

Execute o script duas vezes e veja a mágica acontecer:

if __name__ == "__main__":
    ano_busca = 2026
    
    print("--- Primeira Chamada (deve ir na API) ---")
    feriados = get_feriados(ano_busca)
    print(f"Resultado: {len(feriados)} feriados encontrados.\n")
    
    print("--- Segunda Chamada (deve vir do Cache) ---")
    feriados_cache = get_feriados(ano_busca)
    print(f"Resultado: {len(feriados_cache)} feriados encontrados.")

Por que isso é importante?

• 💰Economia: No plano Free da Feriados API, você tem 100 requisições/mês. Com cache, você gasta apenas 1 requisição por mês (dependendo do TTL) para obter os dados. Seus usuários podem acessar o dashboard mil vezes, e você só terá consumido 1 crédito.
• ⚡Performance: O Redis responde em microssegundos. A API externa depende de DNS, conexão SSL, processamento do servidor e latência da internet.
• 🛡️Resiliência: Se a API externa estiver momentaneamente indisponível, você ainda pode servir os dados que estão no cache (se implementar uma lógica de fallback).

Conclusão

Caching é uma das otimizações mais simples e impactantes que você pode fazer. Ao usar o Redis, você transforma sua cota limitada em um recurso quase infinito para dados estáticos como calendários e feriados.

Comece a usar hoje e aproveite ao máximo seu plano gratuito de Feriados API!