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.
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.
O resto da Posttai (editor, calendário, aprovação, IA e relatório) é igual para todas.
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.
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.com ou WordPress próprio.
Login do WordPress.com ou senha de aplicação, sem código nenhum.
https:// que vai receber os artigos.whsec_…) uma vez só. Guarde numa variável de ambiente do site, como POSTTAI_SEGREDO.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.
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.html já sai escapado e seguro; o markdown vai como foi escrito.ping traz { evento: "ping", entrega, id, criadoEm, marca: { nome } }.{ "url": "https://…" }. O link vira o endereço da publicação, entra no relatório e vai para as redes no "publicar junto".erro, error ou message) na publicação.v1 com 64 caracteres hexadecimais e compare em tempo constante.t com mais de 5 minutos de diferença do seu relógio.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.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: 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 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.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 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 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)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.ETag e responde 304 com If-None-Match; cache de 60 segundos.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.
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
Crie a conta, conecte o site e as redes, e publique tudo junto.