Como Usar a API do Heroku: Guia Completo de Integração (2026)

TL;DR

A API Heroku permite que desenvolvedores automatizem a implantação, gerenciem aplicações, configurem add-ons e escalem a infraestrutura programaticamente. Ela utiliza OAuth 2.0 e autenticação baseada em token, endpoints RESTful para apps, dynos, builds e pipelines, com limites de taxa de 10.000 requisições por hora por conta. Este guia aborda a configuração de autenticação, endpoints principais, integração CI/CD e estratégias de implantação em produção.

Introdução

Heroku alimenta mais de 4 milhões de aplicações em mais de 170 países. Para desenvolvedores que constroem automação de implantação, pipelines CI/CD ou ferramentas de gerenciamento de múltiplas aplicações, a integração com a API Heroku não é opcional – é essencial.

Aqui está a realidade: equipes que gerenciam mais de 10 aplicações Heroku perdem de 8 a 12 horas semanais em implantações manuais e alterações de configuração. Uma integração sólida com a API Heroku automatiza implantações, escala dynos com base no tráfego e sincroniza a configuração entre os ambientes.

Este guia detalha o processo completo de integração com a API Heroku. Você aprenderá sobre autenticação por token, gerenciamento de apps e dynos, pipelines de build, provisionamento de add-ons e solução de problemas. Ao final, você terá uma integração Heroku pronta para produção.

O Que É a API Heroku?

Heroku oferece uma API de Plataforma RESTful para gerenciar aplicações e infraestrutura na plataforma Heroku. A API lida com:

• Criação, configuração e exclusão de aplicações
• Dimensionamento de Dynos e gerenciamento de processos
• Gerenciamento de builds e releases
• Provisionamento e configuração de add-ons
• Gerenciamento de pipelines e promoções
• Gerenciamento de domínios e certificados SSL
• Configuração de log drain e monitoramento
• Gerenciamento de equipes e colaboradores

Funcionalidades Principais

Visão Geral da Arquitetura da API

Heroku usa uma estrutura de API REST versionada:

https://api.heroku.com/

A API segue a especificação JSON:API com padrões e relacionamentos de recursos consistentes.

Versões da API Comparadas

Primeiros Passos: Configuração da Autenticação

Passo 1: Crie Sua Conta Heroku

Antes de acessar a API, você precisa de uma conta Heroku:

1. Visite o site do Heroku
2. Clique em Sign Up (Cadastrar) e crie uma conta
3. Verifique seu endereço de e-mail
4. Conclua a configuração da conta

Passo 2: Instale a CLI do Heroku

A CLI ajuda a gerar tokens de API e testar comandos:

# macOS
brew tap heroku/brew && brew install heroku

# Windows
npm install -g heroku

# Linux
curl https://cli-assets.heroku.com/install.sh | sh

Passo 3: Gere o Token de API

Autentique-se com a CLI do Heroku:

# Faça login no Heroku
heroku login

# Isso abrirá um navegador para autenticação
# Após o login, seu token é armazenado localmente

Recupere seu token de API:

# Visualize seu token de autorização atual
heroku authorizations:create --short-lived

# Ou crie um token de longa duração (para CI/CD)
heroku authorizations:create --description "CI/CD Pipeline" --expires-in "1 year"

Nota de segurança: Armazene tokens em variáveis de ambiente, nunca no código:

# .env file
HEROKU_API_KEY="sua_chave_api_aqui"
HEROKU_APP_NAME="seu-nome-app"

Passo 4: Entenda a Autenticação por Token

Heroku usa autenticação por token Bearer:

Authorization: Bearer {api_key}
Accept: application/vnd.heroku+json; version=3

Toda requisição de API requer esses cabeçalhos.

Passo 5: Faça Sua Primeira Chamada de API

Teste sua autenticação:

curl -n https://api.heroku.com/account \
  -H "Accept: application/vnd.heroku+json; version=3" \
  -H "Authorization: Bearer $HEROKU_API_KEY"

Resposta esperada:

{
  "id": "id-usuario-aqui",
  "email": "desenvolvedor@example.com",
  "name": "Nome do Desenvolvedor",
  "created_at": "2024-01-15T10:30:00Z",
  "updated_at": "2026-03-20T14:22:00Z"
}

Passo 6: Implemente a Autenticação no Código

Crie um cliente de API reutilizável:

const HEROKU_API_KEY = process.env.HEROKU_API_KEY;
const HEROKU_BASE_URL = 'https://api.heroku.com';

const herokuRequest = async (endpoint, options = {}) => {
  const response = await fetch(`${HEROKU_BASE_URL}${endpoint}`, {
    ...options,
    headers: {
      'Authorization': `Bearer ${HEROKU_API_KEY}`,
      'Accept': 'application/vnd.heroku+json; version=3',
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Heroku API Error: ${error.message}`);
  }

  return response.json();
};

// Uso
const account = await herokuRequest('/account');
console.log(`Logado como: ${account.email}`);

Gerenciamento de Aplicações

Criando um Novo App

Crie um app Heroku programaticamente:

const createApp = async (appName, region = 'us') => {
  const response = await herokuRequest('/apps', {
    method: 'POST',
    body: JSON.stringify({
      name: appName,
      region: region
    })
  });

  return response;
};

// Uso
const app = await createApp('meu-app-incrivel-2026');
console.log(`App criado: ${app.name}`);
console.log(`URL Git: ${app.git_url}`);
console.log(`URL Web: ${app.web_url}`);

Resposta Esperada do App

{
  "id": "uuid-app-aqui",
  "name": "meu-app-incrivel-2026",
  "region": { "name": "us" },
  "created_at": "2026-03-25T10:00:00Z",
  "updated_at": "2026-03-25T10:00:00Z",
  "git_url": "https://git.heroku.com/meu-app-incrivel-2026.git",
  "web_url": "https://meu-app-incrivel-2026.herokuapp.com",
  "owner": { "email": "desenvolvedor@example.com" },
  "build_stack": { "name": "heroku-24" }
}

Listando Seus Apps

Busque todos os apps em sua conta:

const listApps = async (limit = 50) => {
  const response = await herokuRequest(`/apps?limit=${limit}`);
  return response;
};

// Uso
const apps = await listApps();
apps.forEach(app => {
  console.log(`${app.name} - ${app.web_url}`);
});

Obtendo Detalhes do App

Recupere informações detalhadas do app:

const getApp = async (appName) => {
  const response = await herokuRequest(`/apps/${appName}`);
  return response;
};

// Uso
const app = await getApp('meu-app-incrivel-2026');
console.log(`Stack: ${app.build_stack.name}`);
console.log(`Região: ${app.region.name}`);

Atualizando a Configuração do App

Modifique as configurações do app:

const updateApp = async (appName, updates) => {
  const response = await herokuRequest(`/apps/${appName}`, {
    method: 'PATCH',
    body: JSON.stringify(updates)
  });

  return response;
};

// Uso - alterar nome do app
const updated = await updateApp('nome-antigo-app', {
  name: 'nome-novo-app'
});

Excluindo um App

Remova um app da sua conta:

const deleteApp = async (appName) => {
  await herokuRequest(`/apps/${appName}`, {
    method: 'DELETE'
  });

  console.log(`App ${appName} excluído com sucesso`);
};

Gerenciamento de Dynos

Dimensionando Dynos

Escale sua aplicação para cima ou para baixo:

const scaleDyno = async (appName, processType, quantity) => {
  const response = await herokuRequest(`/apps/${appName}/formation/${processType}`, {
    method: 'PATCH',
    body: JSON.stringify({
      quantity: quantity
    })
  });

  return response;
};

// Uso - escalar dynos web para 3
const formation = await scaleDyno('meu-app', 'web', 3);
console.log(`Escalado para ${formation.quantity} dynos de ${processType}`);

Obtendo a Formação de Dynos

Visualize a configuração atual de dynos:

const getFormation = async (appName, processType = null) => {
  const endpoint = processType
    ? `/apps/${appName}/formation/${processType}`
    : `/apps/${appName}/formation`;

  const response = await herokuRequest(endpoint);
  return response;
};

// Uso
const formation = await getFormation('meu-app');
formation.forEach(proc => {
  console.log(`${proc.type}: ${proc.quantity} dynos (@ ${proc.size})`);
});

Tamanhos de Dynos Disponíveis

Reiniciando Dynos

Reinicie todos os dynos para um app:

const restartDynos = async (appName, processType = null) => {
  const endpoint = processType
    ? `/apps/${appName}/formation/${processType}`
    : `/apps/${appName}/dynos`;

  await herokuRequest(endpoint, {
    method: 'DELETE'
  });

  console.log(`Dynos reiniciados para ${appName}`);
};

Executando Dynos Avulsos

Execute comandos em dynos isolados:

const runCommand = async (appName, command) => {
  const response = await herokuRequest(`/apps/${appName}/dynos`, {
    method: 'POST',
    body: JSON.stringify({
      command: command,
      size: 'standard-1x'
    })
  });

  return response;
};

// Uso - executar migração de banco de dados
const dyno = await runCommand('meu-app', 'npm run migrate');
console.log(`Dyno iniciado: ${dyno.id}`);

Variáveis de Configuração

Obtendo Variáveis de Configuração

Recupere variáveis de ambiente:

const getConfigVars = async (appName) => {
  const response = await herokuRequest(`/apps/${appName}/config-vars`);
  return response;
};

// Uso
const config = await getConfigVars('meu-app');
console.log(`DATABASE_URL: ${config.DATABASE_URL}`);
console.log(`NODE_ENV: ${config.NODE_ENV}`);

Configurando Variáveis de Configuração

Atualize variáveis de ambiente:

const setConfigVars = async (appName, variables) => {
  const response = await herokuRequest(`/apps/${appName}/config-vars`, {
    method: 'PATCH',
    body: JSON.stringify(variables)
  });

  return response;
};

// Uso
const updated = await setConfigVars('meu-app', {
  NODE_ENV: 'production',
  API_SECRET: 'sua-chave-secreta',
  LOG_LEVEL: 'info'
});

Melhores Práticas para Variáveis de Configuração

1. Nunca commite segredos - Use variáveis de ambiente para todos os dados sensíveis
2. Use configurações separadas por ambiente - Variáveis diferentes para staging vs produção
3. Gire os segredos regularmente - Atualize as chaves de API e senhas trimestralmente
4. Prefixe variáveis relacionadas - STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET

Gerenciamento de Builds e Releases

Criando um Build

Implante código via API:

const createBuild = async (appName, sourceBlobUrl) => {
  const response = await herokuRequest(`/apps/${appName}/builds`, {
    method: 'POST',
    body: JSON.stringify({
      source_blob: {
        url: sourceBlobUrl
      }
    })
  });

  return response;
};

// Uso
const build = await createBuild('meu-app', 'https://storage.example.com/source.tar.gz');
console.log(`Build iniciado: ${build.id}`);
console.log(`Status: ${build.status}`);

Obtendo Status do Build

Verifique o progresso do build:

const getBuild = async (appName, buildId) => {
  const response = await herokuRequest(`/apps/${appName}/builds/${buildId}`);
  return response;
};

// Sondar até completar
const checkBuildStatus = async (appName, buildId, maxAttempts = 30) => {
  for (let i = 0; i < maxAttempts; i++) {
    const build = await getBuild(appName, buildId);

    if (build.status === 'succeeded') {
      console.log('Build bem-sucedido!');
      return build;
    } else if (build.status === 'failed') {
      throw new Error(`Build falhou: ${build.output}`);
    }

    console.log(`Build em andamento... tentativa ${i + 1}`);
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  throw new Error('Tempo limite do build');
};

Listando Releases

Visualize o histórico de releases:

const listReleases = async (appName, limit = 10) => {
  const response = await herokuRequest(`/apps/${appName}/releases?limit=${limit}`);
  return response;
};

// Uso
const releases = await listReleases('meu-app');
releases.forEach(release => {
  console.log(`v${release.version} - ${release.description} - ${release.created_at}`);
});

Revertendo para a Release Anterior

Reverta para uma versão anterior:

const rollback = async (appName, releaseId) => {
  const response = await herokuRequest(`/apps/${appName}/releases`, {
    method: 'POST',
    body: JSON.stringify({
      rollback: releaseId
    })
  });

  return response;
};

// Uso - reverter para a versão 42
const rollbackRelease = await rollback('meu-app', 42);
console.log(`Revertido para v${rollbackRelease.version}`);

Gerenciamento de Pipeline

Criando um Pipeline

Configure pipelines CI/CD:

const createPipeline = async (pipelineName) => {
  const response = await herokuRequest('/pipelines', {
    method: 'POST',
    body: JSON.stringify({
      name: pipelineName
    })
  });

  return response;
};

// Uso
const pipeline = await createPipeline('meu-app-pipeline');
console.log(`Pipeline criado: ${pipeline.id}`);

Adicionando Apps ao Pipeline

Conecte apps a estágios do pipeline:

const addAppToPipeline = async (pipelineId, appName, stage) => {
  const response = await herokuRequest('/pipeline-couplings', {
    method: 'POST',
    body: JSON.stringify({
      pipeline: pipelineId,
      app: appName,
      stage: stage // 'development', 'staging', 'production'
    })
  });

  return response;
};

// Uso
await addAppToPipeline(pipelineId, 'meu-app-dev', 'development');
await addAppToPipeline(pipelineId, 'meu-app-staging', 'staging');
await addAppToPipeline(pipelineId, 'meu-app-prod', 'production');

Promovendo Slug para o Próximo Estágio

Mova o código através do pipeline:

const promoteSlug = async (slugId, toApp) => {
  await herokuRequest('/promotions', {
    method: 'POST',
    body: JSON.stringify({
      from: toApp, // App de origem
      to: toApp,   // App de destino (próximo estágio)
      slug: slugId
    })
  });

  console.log(`Slug ${slugId} promovido para ${toApp}`);
};

Gerenciamento de Add-Ons

Provisionando Add-Ons

Instale add-ons Heroku:

const provisionAddon = async (appName, addonPlan, config = {}) => {
  const response = await herokuRequest('/addon-attachments', {
    method: 'POST',
    body: JSON.stringify({
      app: appName,
      plan: addonPlan,
      config: config
    })
  });

  return response;
};

// Uso - provisionar PostgreSQL
const db = await provisionAddon('meu-app', 'heroku-postgresql:mini', {});
console.log(`Banco de dados provisionado: ${db.addon.name}`);
console.log(`DATABASE_URL: ${db.addon.config_vars.DATABASE_URL}`);

Add-Ons Populares

Listando Add-Ons

Visualize add-ons instalados:

const listAddons = async (appName) => {
  const response = await herokuRequest(`/apps/${appName}/addons`);
  return response;
};

// Uso
const addons = await listAddons('meu-app');
addons.forEach(addon => {
  console.log(`${addon.plan.name} - $${addon.pricing.plan.price} - ${addon.state}`);
});

Removendo Add-Ons

Desinstale add-ons:

const removeAddon = async (appName, addonId) => {
  await herokuRequest(`/apps/${appName}/addons/${addonId}`, {
    method: 'DELETE'
  });

  console.log(`Add-on ${addonId} removido de ${appName}`);
};

Gerenciamento de Domínio e SSL

Adicionando Domínios Personalizados

Configure domínios personalizados:

const addDomain = async (appName, domainName) => {
  const response = await herokuRequest(`/apps/${appName}/domains`, {
    method: 'POST',
    body: JSON.stringify({
      hostname: domainName
    })
  });

  return response;
};

// Uso
const domain = await addDomain('meu-app', 'api.example.com');
console.log(`Alvo CNAME: ${domain.cname}`);

Configurando Certificados SSL

Adicione SSL a domínios personalizados:

const addSslCertificate = async (appName, domainId, certificateChain, privateKey) => {
  const response = await herokuRequest(`/apps/${appName}/domains/${domainId}/ssl_endpoint`, {
    method: 'PATCH',
    body: JSON.stringify({
      ssl_cert: {
        cert_chain: certificateChain,
        private_key: privateKey
      }
    })
  });

  return response;
};

SSL Automatizado com ACM

Habilite o Gerenciamento Automático de Certificados:

const enableACM = async (appName, domainName) => {
  const response = await herokuRequest(`/apps/${appName}/domains/${domainName}/sni_endpoint`, {
    method: 'POST',
    body: JSON.stringify({
      kind: 'acm'
    })
  });

  return response;
};

Limites de Taxa e Cotas

Entendendo os Limites de Taxa

Heroku impõe limites de taxa para proteger a estabilidade da API:

• Limite Padrão: 10.000 requisições por hora por conta
• Janela: Janela de 60 minutos contínuos
• Reset: Automático após a janela passar

Exceder os limites resulta em respostas HTTP 429 (Too Many Requests).

Implementando o Tratamento de Limite de Taxa

Use backoff exponencial para retentativas:

const makeRateLimitedRequest = async (endpoint, options = {}, maxRetries = 3) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await herokuRequest(endpoint, options);

      // Verifique os cabeçalhos de limite de taxa
      const remaining = response.headers.get('RateLimit-Remaining');
      const resetTime = response.headers.get('RateLimit-Reset');

      if (remaining < 100) {
        console.warn(`Cota baixa restante: ${remaining}, reseta em ${resetTime}`);
      }

      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Limite de taxa atingido. Tentando novamente em ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

Cabeçalhos de Limite de Taxa

Heroku inclui esses cabeçalhos em cada resposta:

Solução de Problemas Comuns

Problema: Autenticação Falha com 401

Sintomas: Recebendo erros de “Invalid credentials”.

Soluções:

1. Verifique se a chave de API está correta: heroku authorizations
2. Certifique-se de que o token não expirou (tokens de longa duração duram 1 ano)
3. Verifique por espaços em branco extras na variável de ambiente
4. Gere novamente o token se necessário: heroku authorizations:create

Problema: Nome do App Já Ocupado

Sintomas: Recebendo o erro “name is already taken”.

Soluções:

1. Use nomes globalmente únicos - inclua equipe ou sufixo aleatório
2. Gere nomes baseados em UUID: app-${Date.now()}
3. Use prefixos de namespace: nomedaequipe-nomedoapp-ambiente

const generateUniqueAppName = (baseName) => {
  const timestamp = Date.now().toString(36);
  const random = Math.random().toString(36).substring(2, 6);
  return `${baseName}-${timestamp}-${random}`;
};

Problema: Formação de Dyno Falha

Sintomas: Operações de escalonamento retornam erros.

Soluções:

1. Verifique se o tipo de processo existe no Procfile
2. Verifique se a conta tem cota de dynos disponível
3. Certifique-se de que o app não está suspenso
4. Revise o uso de horas de dyno: heroku ps --app=meu-app

Problema: Build Falha por Tempo Limite

Sintomas: Builds travam ou expiram após 30 minutos.

Soluções:

1. Otimize a seleção de buildpack para sua linguagem
2. Cacheie dependências corretamente
3. Divida builds grandes em implantações menores
4. Use slugs pré-construídos para implantação mais rápida

Problema: Limite de Taxa Excedido

Sintomas: Recebendo respostas HTTP 429.

Soluções:

1. Implemente enfileiramento de requisições
2. Use backoff exponencial para retentativas
3. Agrupe requisições onde possível
4. Monitore os cabeçalhos de limite de taxa proativamente

// Limitador de taxa simples
class HerokuRateLimiter {
  constructor(requestsPerMinute = 150) {
    this.queue = [];
    this.interval = 60000 / requestsPerMinute;
    this.processing = false;
  }

  async add(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.process();
    });
  }

  async process() {
    if (this.processing || this.queue.length === 0) return;

    this.processing = true;

    while (this.queue.length > 0) {
      const { requestFn, resolve, reject } = this.queue.shift();

      try {
        const result = await requestFn();
        resolve(result);
      } catch (error) {
        reject(error);
      }

      if (this.queue.length > 0) {
        await new Promise(r => setTimeout(r, this.interval));
      }
    }

    this.processing = false;
  }
}

Checklist de Implantação em Produção

Antes de entrar em produção:

• [ ] Use tokens de API de longa duração para CI/CD
• [ ] Armazene tokens em gerenciamento de segredos seguro (Vault, AWS Secrets Manager)
• [ ] Implemente limite de taxa e enfileiramento de requisições
• [ ] Adicione tratamento de erros abrangente
• [ ] Configure o registro (logging) para todas as chamadas de API
• [ ] Monitore o uso de horas de dyno
• [ ] Configure log drains para logging externo
• [ ] Configure promoções de pipeline para CI/CD
• [ ] Habilite o Gerenciamento Automático de Certificados
• [ ] Configure estratégia de backup para bancos de dados

Monitoramento e Alerta

Monitore estas métricas:

const metrics = {
  apiCalls: {
    total: 0,
    successful: 0,
    failed: 0,
    rateLimited: 0
  },
  dynoHours: {
    used: 0,
    quota: 1000
  },
  deployments: {
    successful: 0,
    failed: 0,
    avg_duration: 0
  }
};

// Alerte sobre alta taxa de falha
const failureRate = metrics.apiCalls.failed / metrics.apiCalls.total;

if (failureRate > 0.05) {
  sendAlert('Taxa de falha da API Heroku acima de 5%');
}

// Alerte sobre o uso de horas de dyno
if (metrics.dynoHours.used > metrics.dynoHours.quota * 0.8) {
  sendAlert('Uso de horas de dyno acima de 80%');
}

Casos de Uso do Mundo Real

Pipeline CI/CD Automatizado

Uma equipe SaaS automatiza implantações do GitHub:

• Desafio: Implantações manuais causavam erros e atrasos
• Solução: GitHub Actions + integração com a API Heroku
• Resultado: Implantações com zero tempo de inatividade, releases 90% mais rápidas

Fluxo de implementação:

1. Push no GitHub aciona o workflow
2. Testes executados no CI
3. API Heroku cria build a partir do blob de origem
4. Promova de staging para produção
5. Notifique a equipe sobre sucesso/falha

Gerenciamento de Multi-Ambientes

Uma consultoria gerencia mais de 50 apps de clientes:

• Desafio: Sincronização manual de configuração entre ambientes
• Solução: Gerenciamento centralizado de configuração com a API Heroku
• Resultado: Configurações consistentes, 8 horas/semana economizadas

Pontos chave de integração:

• Sincronize variáveis de configuração entre dev/staging/prod
• Provisionamento automatizado de add-ons
• Operações em massa para onboarding de clientes

Autoescalamento Baseado no Tráfego

Uma plataforma de e-commerce lida com picos de tráfego:

• Desafio: Escalonamento manual durante eventos de vendas
• Solução: Autoescalamento baseado em carga com a API Heroku
• Resultado: Zero tempo de inatividade durante picos de tráfego de 10x

Lógica de autoescalamento:

• Monitore tempos de resposta via API de métricas
• Escale para cima quando a latência p95 > 500ms
• Escale para baixo durante períodos de baixo tráfego
• Alerte sobre alta utilização sustentada

Conclusão

A API Heroku oferece acesso abrangente à funcionalidade da plataforma. Principais pontos:

• Autenticação por token Bearer requer armazenamento e rotação seguros
• Limite de taxa (10K/hora) requer monitoramento proativo
• O gerenciamento de pipeline permite workflows robustos de CI/CD
• O tratamento de erros adequado garante a confiabilidade da implantação
• Apidog otimiza o teste de API e a colaboração em equipe para integrações Heroku

Seção de Perguntas Frequentes

Para que serve a API Heroku?

A API Heroku permite o gerenciamento programático de aplicações, dynos, add-ons e infraestrutura. Casos de uso comuns incluem automação de CI/CD, ferramentas de gerenciamento de múltiplos apps, sistemas de autoescalamento e dashboards de monitoramento de infraestrutura.

Como obtenho uma chave de API Heroku?

Instale a CLI do Heroku, execute heroku login e, em seguida, crie uma autorização com heroku authorizations:create. Armazene o token retornado de forma segura em variáveis de ambiente.

A API Heroku é gratuita para usar?

Sim, a API Heroku é gratuita. No entanto, você paga pelos recursos que provisiona (dynos, add-ons, etc.). Os limites de taxa da API são de 10.000 requisições por hora por conta.

Que autenticação a API Heroku usa?

Heroku usa autenticação por token Bearer. Inclua o cabeçalho Authorization: Bearer {api_key} em cada requisição. Os tokens podem ser de curta duração (1 hora) ou de longa duração (até 1 ano).

Como eu lido com os limites de taxa da API Heroku?

Monitore o cabeçalho RateLimit-Remaining e implemente o enfileiramento de requisições. Use backoff exponencial ao receber respostas HTTP 429. Mantenha-se abaixo de 150 requisições por minuto para uma operação segura.

Posso implantar sem Git?

Sim. Use a API de Builds para implantar a partir de uma URL de blob de origem. Faça o upload do seu código para armazenamento em nuvem (S3, GCS) e referencie a URL na sua requisição de build.

Como automatizo implantações?

Use a API de Pipeline para configurar CI/CD. Crie builds, promova slugs através de estágios e integre com GitHub ou sistemas CI personalizados.

Qual a diferença entre um release e um build?

Um build compila seu código-fonte em um slug. Um release combina um slug com variáveis de configuração para criar uma versão implantável do seu app.

Como eu faço rollback de uma implantação que falhou?

Use a API de Releases para listar releases recentes, então faça um POST para /releases com rollback: <release_id>. Heroku cria um novo release na versão anterior.

Posso gerenciar múltiplas contas Heroku?

Sim. Use tokens de API separados para cada conta e alterne entre eles mudando a variável de ambiente HEROKU_API_KEY.