Erro 132000 WhatsApp API: Template Not Found — Como Resolver

O que é o Erro 132000?

O erro 132000 indica que o template especificado não foi encontrado na sua conta do WhatsApp Business. É um dos erros mais comuns ao trabalhar com mensagens de template — e geralmente tem uma causa simples.

{
  "error": {
    "message": "(#132000) Template Not Found",
    "type": "OAuthException",
    "code": 132000,
    "fbtrace_id": "..."
  }
}

Causa 1: Typo no nome do template

O nome do template é case-sensitive e deve bater exatamente com o nome cadastrado no Meta for Developers. Um espaço a mais, uma letra maiúscula ou um underscore errado já dispara o 132000.

Payload incorreto

{
  "messaging_product": "whatsapp",
  "to": "5511999999999",
  "type": "template",
  "template": {
    "name": "boas_vindas",
    "language": { "code": "pt_BR" }
  }
}

Payload correto (template real chama bem_vindo)

{
  "messaging_product": "whatsapp",
  "to": "5511999999999",
  "type": "template",
  "template": {
    "name": "bem_vindo",
    "language": { "code": "pt_BR" }
  }
}

Solução: listar seus templates via API

async function listarTemplates(wabaId, accessToken) {
  const response = await fetch(
    `https://graph.facebook.com/v18.0/${wabaId}/message_templates?fields=name,status,language&limit=100`,
    {
      headers: {
        'Authorization': `Bearer ${accessToken}`
      }
    }
  );

  const data = await response.json();
  
  // Lista todos os templates e seus status
  data.data.forEach(template => {
    console.log(`Nome: ${template.name} | Status: ${template.status} | Idioma: ${template.language}`);
  });

  return data.data;
}

// Buscar template específico pelo nome
async function encontrarTemplate(wabaId, accessToken, nomeTemplate) {
  const templates = await listarTemplates(wabaId, accessToken);
  const encontrado = templates.find(t => t.name === nomeTemplate);
  
  if (!encontrado) {
    console.error(`❌ Template "${nomeTemplate}" não encontrado.`);
    console.log('Templates disponíveis:', templates.map(t => t.name).join(', '));
  } else {
    console.log(`✅ Template encontrado: ${encontrado.name} (${encontrado.status})`);
  }

  return encontrado;
}

Causa 2: Idioma errado no language.code

Um erro muito comum: passar pt quando o template foi criado com pt_BR. O Meta não faz lookup aproximado — o código de idioma precisa ser exato.

Payload incorreto

{
  "template": {
    "name": "bem_vindo",
    "language": { "code": "pt" }
  }
}

Payload correto

{
  "template": {
    "name": "bem_vindo",
    "language": { "code": "pt_BR" }
  }
}

Language codes mais usados

| Idioma | Código correto | |--------|---------------| | Português (Brasil) | pt_BR | | Português (Portugal) | pt_PT | | Inglês (EUA) | en_US | | Inglês (UK) | en_GB | | Espanhol (México) | es_MX | | Espanhol (Argentina) | es_AR | | Francês | fr_FR | | Alemão | de_DE | | Italiano | it_IT |

Consulte a lista completa de idiomas suportados na documentação oficial.

Causa 3: Template rejeitado ou pausado (Erro 132012)

O Meta pode rejeitar ou pausar um template sem notificação imediata. O status muda silenciosamente de APPROVED para PAUSED ou REJECTED — e os próximos envios começam a falhar com 132000 ou 132012.

{
  "error": {
    "message": "(#132012) Message Failed to Send because more than 24 hours have passed since the customer last replied to this number / Template is paused due to low quality rating",
    "type": "OAuthException",
    "code": 132012
  }
}

Verificar status do template via API

async function verificarStatusTemplate(wabaId, accessToken, nomeTemplate) {
  const response = await fetch(
    `https://graph.facebook.com/v18.0/${wabaId}/message_templates?name=${nomeTemplate}&fields=name,status,quality_score,rejected_reason`,
    {
      headers: {
        'Authorization': `Bearer ${accessToken}`
      }
    }
  );

  const data = await response.json();
  const template = data.data[0];

  if (!template) {
    console.log(`Template "${nomeTemplate}" não encontrado.`);
    return null;
  }

  console.log(`Status: ${template.status}`);
  console.log(`Quality score: ${JSON.stringify(template.quality_score)}`);
  
  if (template.rejected_reason) {
    console.log(`Motivo da rejeição: ${template.rejected_reason}`);
  }

  return template;
}

O que fazer dependendo do status

| Status | O que significa | O que fazer | |--------|----------------|------------| | APPROVED | Funcionando | Nada — outro problema | | PAUSED | Pausado por baixa qualidade | Editar o template, aguardar reativação | | REJECTED | Rejeitado pelo Meta | Revisar conteúdo, criar novo template | | PENDING | Aguardando aprovação | Aguardar (pode demorar até 24h) | | DISABLED | Desativado permanentemente | Criar um novo template |

Atenção: templates pausados podem ser reativados editando o conteúdo e aguardando nova revisão. Templates rejeitados precisam de um novo cadastro.

Causa 4: Cache desatualizado após edição do template

Quando você edita um template (seja o nome, idioma ou conteúdo), a Meta processa a mudança mas o código antigo pode continuar usando os dados desatualizados — especialmente se você armazena o nome/idioma do template em banco de dados ou variáveis de ambiente.

Cenário típico:

1. Template cobranca_v1 aprovado e funcionando
2. Dev renomeia para cobranca_v2 e atualiza o painel
3. Código de produção ainda chama cobranca_v1 → 132000

Solução: sempre leia o nome do template de uma fonte confiável (banco de dados atualizado, configuração em painel) e nunca hardcode nomes de templates sem um mecanismo de atualização.

// ❌ Evitar — nome hardcoded
const TEMPLATE_NAME = 'cobranca_v1';

// ✅ Melhor — ler de configuração centralizada
const TEMPLATE_NAME = process.env.WHATSAPP_TEMPLATE_COBRANCA;

// ✅ Ainda melhor — validar na inicialização
async function inicializar() {
  const templateNome = process.env.WHATSAPP_TEMPLATE_COBRANCA;
  const template = await encontrarTemplate(WABA_ID, ACCESS_TOKEN, templateNome);
  
  if (!template || template.status !== 'APPROVED') {
    throw new Error(`Template "${templateNome}" inválido ou não aprovado. Verifique a configuração.`);
  }
  
  console.log(`✅ Template "${templateNome}" validado e pronto.`);
}

Erros relacionados

Erro 132001 — Parameter Missing

O template exige N variáveis, mas o payload enviou menos do que o necessário.

// Template "boas_vindas" tem dois parâmetros: {{1}} e {{2}}

// ❌ Payload incorreto — falta o segundo parâmetro
const payloadErrado = {
  template: {
    name: 'boas_vindas',
    language: { code: 'pt_BR' },
    components: [
      {
        type: 'body',
        parameters: [
          { type: 'text', text: 'João' }
          // Faltou o segundo parâmetro!
        ]
      }
    ]
  }
};

// ✅ Payload correto
const payloadCorreto = {
  template: {
    name: 'boas_vindas',
    language: { code: 'pt_BR' },
    components: [
      {
        type: 'body',
        parameters: [
          { type: 'text', text: 'João' },
          { type: 'text', text: 'Plano Premium' }
        ]
      }
    ]
  }
};

Erro 132005 — Parameter Format Mismatch

O tipo do parâmetro não corresponde ao que o template espera. Por exemplo, passar um text onde o template espera uma image.

// Template com header de imagem

// ❌ Payload incorreto — passando text no header que espera image
const payloadErrado = {
  template: {
    name: 'promo_imagem',
    language: { code: 'pt_BR' },
    components: [
      {
        type: 'header',
        parameters: [
          { type: 'text', text: 'Promoção' } // header espera image!
        ]
      }
    ]
  }
};

// ✅ Payload correto
const payloadCorreto = {
  template: {
    name: 'promo_imagem',
    language: { code: 'pt_BR' },
    components: [
      {
        type: 'header',
        parameters: [
          { type: 'image', image: { link: 'https://seusite.com/promo.jpg' } }
        ]
      }
    ]
  }
};

Helper Function: Preflight Check

Valide tudo antes de disparar a mensagem. Esta função previne os erros 132000, 132001, 132005 e 132012 em tempo de execução.

Node.js

async function preflightCheck(wabaId, accessToken, payload) {
  const { name: templateName, language, components = [] } = payload.template;
  
  // 1. Buscar template na API
  const response = await fetch(
    `https://graph.facebook.com/v18.0/${wabaId}/message_templates?name=${templateName}&fields=name,status,language,components`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );
  
  const data = await response.json();
  const template = data.data?.find(
    t => t.name === templateName && t.language === language.code
  );
  
  // 2. Verificar se existe
  if (!template) {
    const disponíveis = data.data?.map(t => `${t.name} (${t.language})`).join(', ') || 'nenhum';
    throw new Error(
      `Template "${templateName}" com idioma "${language.code}" não encontrado.\n` +
      `Templates disponíveis: ${disponíveis}`
    );
  }
  
  // 3. Verificar status
  if (template.status !== 'APPROVED') {
    throw new Error(
      `Template "${templateName}" não está aprovado. Status atual: ${template.status}`
    );
  }
  
  // 4. Verificar número de parâmetros por componente
  for (const componentPayload of components) {
    const componentTemplate = template.components?.find(
      c => c.type.toLowerCase() === componentPayload.type.toLowerCase()
    );
    
    if (!componentTemplate) continue;
    
    // Contar variáveis no template ({{1}}, {{2}}, etc.)
    const paramsEsperados = (componentTemplate.text?.match(/\{\{\d+\}\}/g) || []).length;
    const paramsEnviados = componentPayload.parameters?.length || 0;
    
    if (paramsEnviados < paramsEsperados) {
      throw new Error(
        `Componente "${componentPayload.type}": esperado ${paramsEsperados} parâmetro(s), recebeu ${paramsEnviados}.`
      );
    }
  }
  
  console.log(`✅ Preflight OK: template "${templateName}" (${language.code}) pronto para envio.`);
  return true;
}

// Uso
async function enviarComValidacao(wabaId, accessToken, phoneNumberId, para, templatePayload) {
  await preflightCheck(wabaId, accessToken, templatePayload);
  
  const response = await fetch(
    `https://graph.facebook.com/v18.0/${phoneNumberId}/messages`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        messaging_product: 'whatsapp',
        to: para,
        type: 'template',
        template: templatePayload.template
      })
    }
  );
  
  return response.json();
}

Python

import requests

def preflight_check(waba_id: str, access_token: str, payload: dict) -> bool:
    template_name = payload["template"]["name"]
    language_code = payload["template"]["language"]["code"]
    components = payload["template"].get("components", [])

    # 1. Buscar template na API
    response = requests.get(
        f"https://graph.facebook.com/v18.0/{waba_id}/message_templates",
        params={
            "name": template_name,
            "fields": "name,status,language,components"
        },
        headers={"Authorization": f"Bearer {access_token}"}
    )
    data = response.json()

    # 2. Verificar se existe
    template = next(
        (t for t in data.get("data", [])
         if t["name"] == template_name and t["language"] == language_code),
        None
    )

    if not template:
        disponíveis = [f"{t['name']} ({t['language']})" for t in data.get("data", [])]
        raise ValueError(
            f'Template "{template_name}" com idioma "{language_code}" não encontrado.\n'
            f'Disponíveis: {", ".join(disponíveis) or "nenhum"}'
        )

    # 3. Verificar status
    if template["status"] != "APPROVED":
        raise ValueError(
            f'Template "{template_name}" não está aprovado. Status: {template["status"]}'
        )

    # 4. Verificar parâmetros
    import re
    for comp_payload in components:
        comp_type = comp_payload["type"].upper()
        comp_template = next(
            (c for c in template.get("components", []) if c["type"] == comp_type),
            None
        )
        if not comp_template:
            continue

        params_esperados = len(re.findall(r'\{\{\d+\}\}', comp_template.get("text", "")))
        params_enviados = len(comp_payload.get("parameters", []))

        if params_enviados < params_esperados:
            raise ValueError(
                f'Componente "{comp_type}": esperado {params_esperados} parâmetro(s), recebeu {params_enviados}.'
            )

    print(f'✅ Preflight OK: template "{template_name}" ({language_code}) pronto para envio.')
    return True


# Uso
def enviar_com_validacao(waba_id, access_token, phone_number_id, para, template_payload):
    preflight_check(waba_id, access_token, template_payload)

    response = requests.post(
        f"https://graph.facebook.com/v18.0/{phone_number_id}/messages",
        headers={
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        },
        json={
            "messaging_product": "whatsapp",
            "to": para,
            "type": "template",
            "template": template_payload["template"]
        }
    )
    return response.json()

Checklist de diagnóstico rápido

• [ ] O nome do template está correto (case-sensitive, sem espaços extras)?
• [ ] O language.code usa o formato correto (ex: pt_BR, não pt)?
• [ ] O template tem status APPROVED no Meta for Developers?
• [ ] O número de parâmetros no payload bate com o template?
• [ ] O tipo de cada parâmetro (text, image, document) está correto?
• [ ] O template não foi editado ou renomeado recentemente sem atualizar o código?
• [ ] O template não foi pausado por baixa qualidade (muitos bloqueios)?

Conclusão

Os erros da família 132xxx geralmente têm uma causa direta e resolvível: nome errado, idioma errado, template fora de ar. O preflight check elimina a maioria desses problemas antes do envio e transforma erros de produção em validações em desenvolvimento.

Precisa de ajuda com a implementação da WhatsApp Business API? Entre em contato para consultoria.