Pular para o conteúdo
Ajuda · Sites e blogs

Conectar o seu site à Posttai

Qualquer site, não só WordPress. A Posttai entrega o artigo por um webhook assinado, ou o seu site busca pela API de conteúdo. Este guia tem o contrato e os exemplos prontos.

Escolha a forma de ligar

O resto da Posttai (editor, calendário, aprovação, IA e relatório) é igual para todas.

Webhook da Posttai

Site com back-end próprio, em qualquer linguagem.

Na hora de publicar, a Posttai manda um POST assinado com o artigo. O site grava e responde com o link.

API de conteúdo

Site estático, Nuxt ou Next com build.

O site busca os artigos com uma chave de leitura, ou pelos feeds JSON e RSS.

WordPress

WordPress.com ou WordPress próprio.

Login do WordPress.com ou senha de aplicação, sem código nenhum.

Conectar pelo webhook

  1. No app, abra Canais, escolha Site e informe a URL https:// que vai receber os artigos.
  2. A Posttai mostra o segredo de assinatura (whsec_…) uma vez só. Guarde numa variável de ambiente do site, como POSTTAI_SEGREDO.
  3. Publique o código que recebe a chamada (veja os exemplos abaixo) e clique em conectar. A Posttai manda um evento ping assinado e só grava o canal se a resposta for 2xx.

A URL precisa ser pública: só https, porta 443 ou 8443, sem usuário na URL e com um nome que resolva para IP público. Endereço interno ou privado é recusado.

O que chega no seu site

Um POST com Content-Type: application/json e estes cabeçalhos:

  • x-posttai-evento: artigo.publicar ou ping.
  • x-posttai-entrega: ent_…, o mesmo em todas as tentativas da mesma publicação. O mesmo valor vem assinado no corpo (entrega): use o do corpo para não gravar duas vezes.
  • x-posttai-assinatura: t=UNIX,v1=HEX, com v1 = HMAC-SHA256(segredo, "T.CORPO") sobre os bytes exatos do corpo (T é o mesmo número do t).

Corpo de artigo.publicar:

{
  "evento": "artigo.publicar",
  "entrega": "ent_3f9a0c1b2d4e5f60718293a4b5c6d7e8",
  "id": "6720f0c1a2b3c4d5e6f70809",
  "titulo": "Café coado: o guia",
  "slug": "cafe-coado-o-guia",
  "resumo": "Como coar café em casa.",
  "html": "<h2>Por que coar</h2>\n<p>…</p>",
  "markdown": "## Por que coar\n\n…",
  "imagens": [
    {
      "url": "https://cdn.posttai.com/…/capa.webp",
      "alt": "Xícara de café",
      "largura": 1200,
      "altura": 630
    }
  ],
  "categorias": [
    "Receitas"
  ],
  "tags": [
    "café"
  ],
  "seo": {
    "titulo": "Café coado: o guia",
    "descricao": "Como coar café em casa.",
    "palavraChave": "café coado"
  },
  "publicarEm": "2026-10-10T12:00:00.000Z",
  "idioma": "pt-BR",
  "marca": {
    "nome": "Sua marca"
  }
}
  • id é o id do post na Posttai (o mesmo se o artigo for reenviado). marca leva só o nome.
  • O html já sai escapado e seguro; o markdown vai como foi escrito.
  • O ping traz { evento: "ping", entrega, id, criadoEm, marca: { nome } }.

Resposta, erros e novas tentativas

  • Deu certo: responda 2xx com { "url": "https://…" }. O link vira o endereço da publicação, entra no relatório e vai para as redes no "publicar junto".
  • Erro definitivo: 4xx (menos 408 e 429) para na hora, com a sua mensagem (erro, error ou message) na publicação.
  • Tenta de novo: 5xx, 408, 429, tempo esgotado ou queda de rede voltam para a fila em 1, 5, 15 e 60 minutos (5 tentativas no total).
  • Redirecionamento (3xx) não é seguido. O prazo de cada chamada é de 15 segundos.
  • Se falhar de vez, o post fica com erro e o sino do app avisa.

Conferir a assinatura

  • Confira com o corpo cru, antes de interpretar o JSON.
  • Aceite só v1 com 64 caracteres hexadecimais e compare em tempo constante.
  • Recuse t com mais de 5 minutos de diferença do seu relógio.
  • Troca do segredo sem parar: ao gerar um segredo novo, por 24 horas o cabeçalho leva dois v1 (o novo e o anterior). Aceite a chamada se qualquer v1 bater com POSTTAI_SEGREDO ou POSTTAI_SEGREDO_ANTERIOR; passado o prazo, apague o anterior.

Exemplos prontos

Os mesmos da tela do canal no app. Todos conferem a assinatura, devolvem 400 para pedido inválido, 5xx quando falha ao gravar (a Posttai tenta de novo) e gravam uma vez só por entrega.

Node (Express)
// Node + Express: npm i express
import express from 'express'
import crypto from 'node:crypto'

const app = express()
// Segredos aceitos: o atual e, durante a troca, o anterior. Sempre em variável de ambiente.
const SEGREDOS = [process.env.POSTTAI_SEGREDO, process.env.POSTTAI_SEGREDO_ANTERIOR].filter(Boolean)
const HEX64 = /^[0-9a-f]{64}$/

// corpo: Buffer com os bytes exatos; cabecalho: "t=<unix>,v1=<hex>[,v1=<hex>]".
function assinaturaValida (corpo, cabecalho, segredos = SEGREDOS) {
  const partes = String(cabecalho || '').split(',').map(p => p.trim())
  const tTexto = partes.find(p => p.startsWith('t='))?.slice(2) || ''
  const t = /^\d{1,12}$/.test(tTexto) ? Number(tTexto) : 0
  // Só v1 com 64 caracteres hex; o resto é descartado ANTES de comparar (bytes com bytes, 32 e 32).
  const recebidas = partes.filter(p => p.startsWith('v1=')).map(p => p.slice(3)).filter(v => HEX64.test(v)).map(v => Buffer.from(v, 'hex'))
  if (!t || !recebidas.length || Math.abs(Date.now() / 1000 - t) > 300) return false // janela de 5 min
  return segredos.some(segredo => {
    const esperada = crypto.createHmac('sha256', segredo).update(`${t}.`).update(corpo).digest()
    return recebidas.some(r => crypto.timingSafeEqual(r, esperada))
  })
}

// express.raw: a assinatura é sobre os bytes exatos do corpo (nada de express.json antes desta rota).
app.post('/api/posttai', express.raw({ type: 'application/json', limit: '2mb' }), async (req, res) => {
  let dados
  try {
    const corpo = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0)
    if (!assinaturaValida(corpo, req.get('x-posttai-assinatura'))) return res.status(401).json({ erro: 'Assinatura inválida' })
    dados = JSON.parse(corpo.toString('utf8'))
  } catch {
    return res.status(400).json({ erro: 'Pedido inválido' })
  }
  if (dados?.evento === 'ping') return res.json({ ok: true })
  if (dados?.evento !== 'artigo.publicar' || typeof dados.entrega !== 'string') return res.status(400).json({ erro: 'Evento desconhecido' })
  try {
    // dados.entrega vem DENTRO do corpo assinado e se repete nas novas tentativas:
    // grave o artigo uma vez só por entrega (ex.: índice único na sua tabela).
    const url = await salvarArtigo(dados.entrega, dados) // sua função: devolve o link do artigo
    return res.json({ url })
  } catch {
    return res.status(500).json({ erro: 'Falha ao gravar' }) // 5xx: a Posttai tenta de novo
  }
})

app.listen(3000)
Nuxt (server route)
// Nuxt 3: server/api/posttai.post.ts
import crypto from 'node:crypto'

const HEX64 = /^[0-9a-f]{64}$/

function assinaturaValida (corpo: Buffer, cabecalho: string, segredos: string[]) {
  const partes = cabecalho.split(',').map(p => p.trim())
  const tTexto = partes.find(p => p.startsWith('t='))?.slice(2) || ''
  const t = /^\d{1,12}$/.test(tTexto) ? Number(tTexto) : 0
  // Só v1 com 64 caracteres hex; o resto é descartado ANTES de comparar.
  const recebidas = partes.filter(p => p.startsWith('v1=')).map(p => p.slice(3)).filter(v => HEX64.test(v)).map(v => Buffer.from(v, 'hex'))
  if (!t || !recebidas.length || Math.abs(Date.now() / 1000 - t) > 300) return false
  return segredos.some(segredo => {
    const esperada = crypto.createHmac('sha256', segredo).update(`${t}.`).update(corpo).digest()
    return recebidas.some(r => crypto.timingSafeEqual(r, esperada))
  })
}

export default defineEventHandler(async (event) => {
  const segredos = [process.env.POSTTAI_SEGREDO, process.env.POSTTAI_SEGREDO_ANTERIOR].filter(Boolean) as string[]
  let dados: any
  try {
    const corpo = (await readRawBody(event, false)) || Buffer.alloc(0) // bytes exatos
    if (!assinaturaValida(corpo, getHeader(event, 'x-posttai-assinatura') || '', segredos)) {
      setResponseStatus(event, 401)
      return { erro: 'Assinatura inválida' }
    }
    dados = JSON.parse(corpo.toString('utf8'))
  } catch {
    setResponseStatus(event, 400)
    return { erro: 'Pedido inválido' }
  }
  if (dados?.evento === 'ping') return { ok: true }
  if (dados?.evento !== 'artigo.publicar' || typeof dados.entrega !== 'string') {
    setResponseStatus(event, 400)
    return { erro: 'Evento desconhecido' }
  }
  // dados.entrega vem no corpo assinado e se repete nas novas tentativas: grave uma vez só por entrega.
  const url = await salvarArtigo(dados.entrega, dados) // sua função; se lançar, o Nuxt responde 500 e a Posttai tenta de novo
  return { url }
})
Next (route handler)
// Next.js (App Router): app/api/posttai/route.ts
import crypto from 'node:crypto'

export const runtime = 'nodejs' // node:crypto

const SEGREDOS = [process.env.POSTTAI_SEGREDO, process.env.POSTTAI_SEGREDO_ANTERIOR].filter(Boolean) as string[]
const HEX64 = /^[0-9a-f]{64}$/

function assinaturaValida (corpo: Buffer, cabecalho: string) {
  const partes = cabecalho.split(',').map(p => p.trim())
  const tTexto = partes.find(p => p.startsWith('t='))?.slice(2) || ''
  const t = /^\d{1,12}$/.test(tTexto) ? Number(tTexto) : 0
  // Só v1 com 64 caracteres hex; o resto é descartado ANTES de comparar.
  const recebidas = partes.filter(p => p.startsWith('v1=')).map(p => p.slice(3)).filter(v => HEX64.test(v)).map(v => Buffer.from(v, 'hex'))
  if (!t || !recebidas.length || Math.abs(Date.now() / 1000 - t) > 300) return false
  return SEGREDOS.some(segredo => {
    const esperada = crypto.createHmac('sha256', segredo).update(`${t}.`).update(corpo).digest()
    return recebidas.some(r => crypto.timingSafeEqual(r, esperada))
  })
}

export async function POST (req: Request) {
  let dados: any
  try {
    const corpo = Buffer.from(await req.arrayBuffer()) // bytes exatos, antes de qualquer JSON.parse
    if (!assinaturaValida(corpo, req.headers.get('x-posttai-assinatura') || '')) {
      return Response.json({ erro: 'Assinatura inválida' }, { status: 401 })
    }
    dados = JSON.parse(corpo.toString('utf8'))
  } catch {
    return Response.json({ erro: 'Pedido inválido' }, { status: 400 })
  }
  if (dados?.evento === 'ping') return Response.json({ ok: true })
  if (dados?.evento !== 'artigo.publicar' || typeof dados.entrega !== 'string') {
    return Response.json({ erro: 'Evento desconhecido' }, { status: 400 })
  }
  // dados.entrega vem no corpo assinado e se repete nas novas tentativas: grave uma vez só por entrega.
  const url = await salvarArtigo(dados.entrega, dados) // sua função; se lançar, o Next responde 500 e a Posttai tenta de novo
  return Response.json({ url })
}
PHP
<?php
// PHP 7.4+: posttai.php
header('Content-Type: application/json');

function assinatura_valida(string $corpo, string $cabecalho, array $segredos): bool
{
    $t = 0;
    $recebidas = [];
    foreach (explode(',', $cabecalho) as $parte) {
        $par = explode('=', trim($parte), 2);
        if (count($par) !== 2) continue;
        [$chave, $valor] = $par;
        if ($chave === 't' && preg_match('/^[0-9]{1,12}\z/', $valor) === 1) $t = (int) $valor;
        // Só v1 com 64 caracteres hex; o resto é descartado antes de comparar.
        if ($chave === 'v1' && preg_match('/^[0-9a-f]{64}\z/', $valor) === 1) $recebidas[] = $valor;
    }
    if ($t === 0 || count($recebidas) === 0 || abs(time() - $t) > 300) return false;
    foreach ($segredos as $segredo) {
        $esperada = hash_hmac('sha256', $t . '.' . $corpo, $segredo);
        foreach ($recebidas as $r) {
            if (hash_equals($esperada, $r)) return true;
        }
    }
    return false;
}

try {
    $corpo = file_get_contents('php://input'); // bytes exatos
    $segredos = array_filter([getenv('POSTTAI_SEGREDO'), getenv('POSTTAI_SEGREDO_ANTERIOR')]);
    if (!is_string($corpo) || !assinatura_valida($corpo, (string) ($_SERVER['HTTP_X_POSTTAI_ASSINATURA'] ?? ''), $segredos)) {
        http_response_code(401);
        echo json_encode(['erro' => 'Assinatura inválida']);
        exit;
    }
    $dados = json_decode($corpo, true, 64, JSON_THROW_ON_ERROR);
} catch (\Throwable $e) {
    http_response_code(400);
    echo json_encode(['erro' => 'Pedido inválido']);
    exit;
}

$evento = is_array($dados) ? ($dados['evento'] ?? '') : '';
if ($evento === 'ping') {
    echo json_encode(['ok' => true]);
    exit;
}
if ($evento !== 'artigo.publicar' || !is_string($dados['entrega'] ?? null)) {
    http_response_code(400);
    echo json_encode(['erro' => 'Evento desconhecido']);
    exit;
}

// $dados['entrega'] vem no corpo assinado e se repete nas novas tentativas: grave uma vez só por entrega.
$url = salvar_artigo($dados['entrega'], $dados); // sua função: devolve o link (se falhar, responda 500)
echo json_encode(['url' => $url]);
Python (Flask)
# Python 3 + Flask: pip install flask
import hashlib
import hmac
import json
import os
import re
import time

from flask import Flask, jsonify, request

app = Flask(__name__)
SEGREDOS = [s for s in (os.environ.get('POSTTAI_SEGREDO'), os.environ.get('POSTTAI_SEGREDO_ANTERIOR')) if s]
HEX64 = re.compile(r'[0-9a-f]{64}')
NUMERO = re.compile(r'[0-9]{1,12}')


def assinatura_valida(corpo: bytes, cabecalho: str) -> bool:
    partes = [p.strip() for p in (cabecalho or '').split(',')]
    t_texto = next((p[2:] for p in partes if p.startswith('t=')), '')
    t = int(t_texto) if NUMERO.fullmatch(t_texto) else 0
    # Só v1 com 64 caracteres hex; o resto é descartado antes de comparar (bytes com bytes).
    recebidas = [bytes.fromhex(p[3:]) for p in partes if p.startswith('v1=') and HEX64.fullmatch(p[3:])]
    if not t or not recebidas or abs(time.time() - t) > 300:
        return False
    for segredo in SEGREDOS:
        esperada = hmac.new(segredo.encode(), f'{t}.'.encode() + corpo, hashlib.sha256).digest()
        if any(hmac.compare_digest(esperada, r) for r in recebidas):
            return True
    return False


@app.post('/api/posttai')
def posttai():
    try:
        corpo = request.get_data(cache=False)  # bytes exatos
        if not assinatura_valida(corpo, request.headers.get('x-posttai-assinatura', '')):
            return jsonify(erro='Assinatura inválida'), 401
        dados = json.loads(corpo)
    except Exception:
        return jsonify(erro='Pedido inválido'), 400
    if not isinstance(dados, dict):
        return jsonify(erro='Pedido inválido'), 400
    if dados.get('evento') == 'ping':
        return jsonify(ok=True)
    if dados.get('evento') != 'artigo.publicar' or not isinstance(dados.get('entrega'), str):
        return jsonify(erro='Evento desconhecido'), 400
    # dados['entrega'] vem no corpo assinado e se repete nas novas tentativas: grave uma vez só por entrega.
    url = salvar_artigo(dados['entrega'], dados)  # sua função: devolve o link (se lançar, o Flask responde 500)
    return jsonify(url=url)

API de conteúdo e feeds

Para site estático ou com build: gere uma chave de leitura (pts_…) na tela do canal e mande no cabeçalho Authorization: Bearer. A chave lê só os artigos daquele canal (planos Profissional / Agência).

  • GET /v1/sites/:idCanal/artigos?pagina=1&porPagina=20&desde=… lista os artigos publicados, mais novos primeiro (até 100 por página).
  • GET /v1/sites/:idCanal/artigos/:slug traz um artigo.
  • GET /v1/sites/:idCanal/feed.json e /rss.xml são os feeds públicos, se ligados no canal.
  • Toda resposta tem ETag e responde 304 com If-None-Match; cache de 60 segundos.
  • Limites: 120 leituras por minuto por chave e 300 por IP.
  • A chave é só para o servidor ou o build do site. Nunca no código que vai para o navegador; para ler direto no navegador, use os feeds.
curl https://api.posttai.com/v1/sites/ID_DO_CANAL/artigos \
  -H "Authorization: Bearer $POSTTAI_CHAVE_SITE"

Aviso de deploy: informe a URL do deploy hook (Vercel, Netlify, DigitalOcean, Cloudflare) e, depois de cada artigo publicado, a Posttai chama o hook para o site refazer o build.

Publicar junto

No editor, marque Publicar o artigo no site e as redes com o link. O artigo sai primeiro; as redes recebem o texto com o link do artigo, com UTM e pelo encurtador da Posttai, para você ver os cliques de cada rede. Se o site demorar, as redes esperam até 30 minutos (ou saem sem o link, se você preferir).

A IA também escreve o artigo a partir do post ou do carrossel, com título, resumo, slug e SEO.

Comece hoje

Ponha o seu site no calendário

Crie a conta, conecte o site e as redes, e publique tudo junto.

  • 7 dias grátis
  • Sem cartão para testar
  • Posts ilimitados em todos os planos
Fale com a gente