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

• 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

• APPROVED - O que significa: Funcionando - O que fazer: Nada - outro problema
• PAUSED - O que significa: Pausado por baixa qualidade - O que fazer: Editar o template, aguardar reativação
• REJECTED - O que significa: Rejeitado pelo Meta - O que fazer: Revisar conteúdo, criar novo template
• PENDING - O que significa: Aguardando aprovação - O que fazer: Aguardar (pode demorar até 24h)
• DISABLED - O que significa: Desativado permanentemente - O que fazer: 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.