Seu conteúdo. Suas ferramentas. Vá construir algo.

CONHEÇA SUA PRÓXIMA CONEXÃO

Dê às suas ferramentas de IA
algo com o qual trabalhar.

Coloque seu cliente de IA para trabalhar em sua publicação. MCP oferece ferramentas de clientes compatíveis para ler conteúdo, inspecionar rascunhos, salvar revisões e, com uma concessão de proprietário explícita, conteúdo de publicação na fila.

{
  "name": "published_articles_list",
  "arguments": {
    "publicationId": "PUBLICATION_UUID",
    "input": {
      "limit": 3
    }
  }
}

CONECTAR / HTTP TRANSMISSÍVEL

Faça a conexão.

Conecte um cliente MCP compatível usando HTTP Transmissível em https://app.endata.com/mcp. Os esquemas de ferramenta vêm do mesmo registro de operações que a API HTTP.

O aplicativo chama isso de projeto. As rotas da API e os campos de solicitação mantêm publication e publicationId; use esses nomes exatos no código.

Está criando um agente? Siga o guia passo a passo: Crie um fluxo de conteúdo automatizado com o servidor MCP.

Codex

Adicione isto ao ~/.codex/config.toml. Disponibilize sua chave da API do projeto como ENDATA_API_KEY no ambiente que inicia Codex.

[mcp_servers.endata]
url = "https://app.endata.com/mcp"
bearer_token_env_var = "ENDATA_API_KEY"

Claude Code

Adicione isto ao .mcp.json do seu projeto. Defina ENDATA_API_KEY no ambiente antes de iniciar Claude Code. Mantenha a chave fora dos arquivos de configuração e controle de origem.

{
  "mcpServers": {
    "endata": {
      "type": "http",
      "url": "https://app.endata.com/mcp",
      "headers": { "Authorization": "Bearer ${ENDATA_API_KEY}" }
    }
  }
}

Estes exemplos usam a configuração HTTP MCP documentada dos clientes. A conexão e as ferramentas disponíveis dependem dos escopos e permissões do projeto de sua chave.

Construa seu próprio cliente MCP

// Node.js com @modelcontextprotocol/sdk instalado.
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from
  "@modelcontextprotocol/sdk/client/streamableHttp.js";

const client = new Client({ name: "my-endata-tool", version: "1.0.0" });
await client.connect(new StreamableHTTPClientTransport(
  new URL("https://app.endata.com/mcp"),
  { requestInit: { headers: {
    Authorization: `Bearer ${process.env.ENDATA_API_KEY}`,
  } } }
));
try {
  const result = await client.callTool({
    name: "published_articles_list",
    arguments: {
      publicationId: process.env.ENDATA_PUBLICATION_ID,
      input: { limit: 20 },
    },
  });
  if (result.isError) throw new Error(JSON.stringify(result.content));
  console.log(result.content);
} finally {
  await client.close();
}

Isto usa o SDK MCP TypeScript oficial, não um SDK específico de Endata. Configure credenciais de portador através das configurações de conexão segura do seu cliente. Conexões de chave de API são suportadas; OAuth pessoal e registro de cliente são diferidos.

01 / SEU PRIMEIRO PEDIDO

Pegue uma chave. Obtenha algum conteúdo.

Crie uma chave da API do projeto em Configurações → Desenvolvedor → Chaves da API. Comece com published:read e faça seu primeiro pedido em um servidor ou em seu ambiente de construção.

// JavaScript no servidor. Mantenha as credenciais fora dos pacotes do navegador.
const base = "https://app.endata.com/api/v1";
const publication = process.env.ENDATA_PUBLICATION_ID;
const headers = { Authorization: `Bearer ${process.env.ENDATA_API_KEY}` };
const response = await fetch(
  `${base}/publications/${publication}/articles?limit=20`,
  { headers, cache: "no-store" }
);
if (!response.ok) throw new Error(`Endata returned ${response.status}`);
const { items, editionId, hasMore } = await response.json();
for (const article of items) {
  console.log(article.title, article.slug);
}

{
  "publication": {
    "id": "PUBLICATION_UUID",
    "name": "Resumo do setor",
    "slug": "industry-brief"
  },
  "editionId": "EDITION_UUID",
  "items": [
    {
      "id": "ARTICLE_UUID",
      "slug": "a-new-perspective",
      "title": "Um novo olhar sobre o seu setor",
      "summary": "O que importa no que acontece no seu setor, com o seu contexto editorial.",
      "body": "<p>Conteúdo do artigo revisado.</p>",
      "sources": [
        {
          "title": "Relatório original",
          "url": "https://example.com/report"
        }
      ],
      "disclosure": "Preparado com apoio de IA e revisado pela equipe editorial."
    }
  ],
  "hasMore": false
}

02 / ACESSO COM INTENÇÃO

Você escolhe quem tem acesso.

As chaves pertencem a um projeto e atuam como contas de serviço. Escolha apenas os escopos de que sua integração precisa. A expiração é opcional; a revogação é verificada em cada solicitação.

Escopos, funções de serviço e limites de plano se aplicam. Ações consequentes, como publicação, agendamento, exclusão e alterações administrativas, também exigem concessões de proprietário autônomo explícitas. OAuth pessoal ainda não está disponível.

Publicação, compartilhamento externo e convites também exigem o e-mail verificado do criador da chave da API. Um 403 com email_unverified significa que essa pessoa deve verificar seu e-mail na plataforma antes de tentar novamente.

03 / OS BLOCOS DE CONSTRUÇÃO

Explore pelo que você está construindo.

Explore 77 operações em 12 áreas. Cada operação usa a mesma estrutura de rota POST. O catálogo ao vivo contém os escopos exatos e esquemas de entrada.

Operações sociais suportam perfis e páginas LinkedIn, Facebook, X, Threads, Instagram, Bluesky, TikTok e YouTube Shorts. Postagens TikTok e YouTube usam format: "video" e postagens TikTok também aceitam options.privacyLevel. Conectar uma conta primeiro requer consentimento interativo em Distribuição. Integrações de newsletter coletam assinantes; elas não enviam campanhas de e-mail.

API / SUA CAMADA DE APRESENTAÇÃO

Nós trazemos o conteúdo.
Você cria a experiência.

Use Endata como seu backend editorial e construa o front-end que sua audiência precisa. Seu site, aplicativo ou portal de cliente pode renderizar os mesmos artigos aprovados com seu próprio layout, navegação e marca.

04 / CONTEÚDO QUE PERMANECE CONSISTENTE

Leia uma edição, não um alvo em movimento.

Use as rotas GET do artigo para entrega de conteúdo. Fixe páginas subsequentes ao editionId da primeira resposta, depois substitua seu conteúdo local apenas após a atualização inteira ter sucesso.

// Fixe as páginas seguintes na edição da primeira página.
// Reaproveite base, publication e headers do início rápido.
const collected = [];
let editionId;
let offset = 0;
while (true) {
  const query = new URLSearchParams({ limit: "100", offset: String(offset) });
  if (editionId) query.set("edition", editionId);
  const response = await fetch(
    `${base}/publications/${publication}/articles?${query}`,
    { headers, cache: "no-store" }
  );
  if (!response.ok) throw new Error(`Refresh failed: ${response.status}`);
  const page = await response.json();
  editionId ??= page.editionId;
  collected.push(...page.items);
  if (!page.hasMore) break;
  offset += page.items.length;
  if (!page.items.length || offset > 10000) {
    throw new Error("Pagination limit reached; preserve the previous export.");
  }
}
// Só substitua sua exportação anterior depois que todas as páginas forem lidas com sucesso.
// Uma edição vazia obtida com sucesso significa que o conteúdo antigo deve ser removido.

Atualizações com falha devem preservar sua exportação anterior. Uma edição vazia bem-sucedida deve remover conteúdo antigo. Edições retidas mais antigas podem permanecer legíveis; o despublishing em estágio não é apagamento histórico.

05 / MAIS QUE UM FEED DE CONTEÚDO

Faça seu fluxo de trabalho funcionar para você.

Prepare rascunhos, salve revisões, aprove conteúdo revisado e conteúdo de publicação na fila como operações distintas. A chave de solicitação de uma gravação torna as tentativas de rede seguras sem repetir a mutação.

// Função auxiliar de operações no servidor. Reutilize uma chave de requisição apenas com dados idênticos.
async function operation(name, input, requestKey) {
  const response = await fetch(
    `${base}/publications/${publication}/operations/${name}`,
    {
      method: "POST",
      headers: {
        ...headers,
        "Content-Type": "application/json",
        "Idempotency-Key": requestKey,
      },
      body: JSON.stringify(input),
    }
  );
  if (!response.ok) throw new Error(`Operation failed: ${response.status}`);
  return response.json();
}
// Use os IDs reais do artigo que você já revisou.
await operation("article_approve", {
  articleId: "ARTICLE_UUID",
  revisionId: "REVIEWED_REVISION_UUID",
}, "approve-article-revision-001");

// Ação separada e de consequência: exige publishing:manage
// E uma autorização explícita do proprietário para uso sem supervisão da chave de serviço.
await operation("publication_publish", {}, "publish-edition-001");
// A publicação é assíncrona. Consulte publishing_read ou receba os eventos.

Este exemplo estende a base, publicação e cabeçalhos do início rápido JavaScript. Substitua espaços reservados UUID por IDs de artigo e revisão reais. Um lote de publicação inclui todas as revisões aprovadas e remoções em estágio elegíveis na publicação, não apenas um artigo.

06 / SIGA O EVENTO

Pressione play no fluxo inteiro.

Caminhe pela aprovação, publicação e entrega de webhook. Mude cenários para ver por que um receptor precisa de tentativas e proteção de duplicação.

07 / QUANDO ALGO MUDA

Verifique. Persista. Reconheça.

Registre um endpoint HTTPS em Configurações → Desenvolvedor → Webhooks. Escolha eventos, salve o segredo de assinatura quando for emitido e verifique o corpo exato da solicitação antes de processar.

import { createHmac, timingSafeEqual } from "node:crypto";

// Passe o corpo da requisição em UTF-8, exato e sem alterações, junto com os cabeçalhos.
function verifyWebhook(rawBody, headers, secret) {
  const timestamp = headers.get("Webhook-Timestamp");
  const signature = headers.get("Webhook-Signature");
  if (!timestamp || !/^\d+$/.test(timestamp)) return false;
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > 300) return false;
  if (!/^v1=[a-f0-9]{64}$/.test(signature || "")) return false;

  const expected = createHmac("sha256", secret)
    .update(timestamp + "." + rawBody, "utf8")
    .digest();
  const received = Buffer.from(signature.slice(3), "hex");
  return timingSafeEqual(expected, received);
}
// Depois da verificação, interprete e valide o evento.
// Grave-o de forma atômica, com uma restrição de unicidade em Webhook-Id.
// Responda 2xx depois de gravar; eventos duplicados também devem responder 2xx.
// Processe de forma assíncrona e concilie o estado atual pela API.

Os eventos transportam IDs de recursos e metadados de transição, não corpos de artigos. "edition.published" sinaliza ativação de edição real. Seu receptor deve ativar sua própria compilação ou atualização; registrar um webhook não implanta seu site.

08 / PRONTO PARA O MUNDO REAL

Planeje para o ocasional problema.