Paginação & Cursor

# Primeira página
curl -X GET "https://requests.prod.judit.io/requests?page=1&page_size=10" \
  -H "api-key: $JUDIT_API_KEY"

# Página específica
curl -X GET "https://requests.prod.judit.io/requests?page=3&page_size=25" \
  -H "api-key: $JUDIT_API_KEY"

def get_tracking_page(page=1, status=None):
    """Busca página de monitoramentos"""
    params = {'page': page}
    
    if status:
        params['status'] = status
    
    response = requests.get(
        "https://tracking.prod.judit.io/tracking",
        headers=headers,
        params=params
    )
    
    return response.json() if response.status_code == 200 else None

# Buscar monitoramentos ativos
active_tracking = get_tracking_page(page=1, status='active', status='updated', status='updating')

# Para listagens rápidas
small_page = get_requests_page(page=1, page_size=10)

# Para processamento em lote
large_page = get_requests_page(page=1, page_size=100)  # Máximo

import concurrent.futures

def fetch_page_range(start_page, end_page, page_size=50):
    """Busca múltiplas páginas em paralelo"""
    
    def fetch_single_page(page):
        return get_requests_page(page, page_size)
    
    results = []
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        # Submeter todas as páginas
        future_to_page = {
            executor.submit(fetch_single_page, page): page 
            for page in range(start_page, end_page + 1)
        }
        
        # Coletar resultados
        for future in concurrent.futures.as_completed(future_to_page):
            page_num = future_to_page[future]
            try:
                page_data = future.result()
                if page_data:
                    results.append((page_num, page_data))
            except Exception as e:
                print(f"Erro na página {page_num}: {e}")
    
    # Ordenar por número da página
    results.sort(key=lambda x: x[0])
    return [data for _, data in results]

# Buscar páginas 1-5 em paralelo
parallel_results = fetch_page_range(1, 5)

import time

def paginate_with_rate_limit(endpoint, delay=0.2):
    """Paginação respeitando rate limits"""
    page = 1
    all_data = []
    
    while True:
        # Fazer requisição
        data = get_requests_page(page, 50)
        
        if not data or not data.get('page_data'):
            break
            
        all_data.extend(data['page_data'])
        
        # Verificar se ainda há páginas para percorrer
        if page >= data.get('all_pages_count', 1):
            break
        
        page += 1
        
        # Delay para respeitar rate limit
        time.sleep(delay)
        
        print(f"Página {page} processada, "
              f"total: {len(all_data)} itens")
    
    return all_data