Tu contenido. Tus herramientas. Ve y construye algo.

CONOCE TU PRÓXIMA CONEXIÓN

Dale a tus herramientas de IA
algo con qué trabajar.

Pon tu cliente de IA a trabajar en tu publicación. MCP da a los clientes compatibles herramientas para leer contenido, inspeccionar borradores, guardar revisiones y, con una concesión explícita del propietario, poner en cola la publicación.

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

CONECTAR / HTTP TRANSMISIBLE

Haz la conexión.

Conecta un cliente MCP compatible usando HTTP Transmisible en https://app.endata.com/mcp. Los esquemas de herramientas provienen del mismo registro de operaciones que la API HTTP.

La aplicación llama a esto un proyecto. Las rutas de la API y los campos de solicitud retienen publication y publicationId; usa esos nombres exactos en el código.

Códice

Añade esto a ~/.codex/config.toml. Haz tu clave de API de proyecto disponible como ENDATA_API_KEY en el entorno que inicia Códice.

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

Código de Claude

Añade esto a .mcp.json de tu proyecto. Establece ENDATA_API_KEY en el entorno antes de iniciar Claude Code. Mantén la clave misma fuera de los archivos de configuración y del control de código fuente.

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

Estos ejemplos usan la configuración HTTP MCP documentada de los clientes. La conexión y las herramientas disponibles dependen de los ámbitos de tu clave y los permisos del proyecto.

Crea tu propio cliente MCP

// Node.js con @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: "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();
}

Esto usa el SDK TypeScript oficial de MCP, no un SDK específico de Endata. Configura las credenciales del portador a través de la configuración de conexión segura de tu cliente. Se admiten conexiones de clave de API; OAuth personal y el registro de cliente están diferidos.

01 / TU PRIMERA SOLICITUD

Coge una clave. Obtén contenido.

Crea una clave de API de proyecto en Configuración → Desarrollador → Claves de API. Empieza con published:read y ejecuta tu primera solicitud en un servidor o en tu entorno de compilación.

// JavaScript en el servidor. Mantén las credenciales fuera de los paquetes del 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": "Resumen del sector",
    "slug": "industry-brief"
  },
  "editionId": "EDITION_UUID",
  "items": [
    {
      "id": "ARTICLE_UUID",
      "slug": "a-new-perspective",
      "title": "Una nueva mirada a tu sector",
      "summary": "Lo que importa de lo que ocurre en tu sector, con tu contexto editorial.",
      "body": "<p>Contenido del artículo revisado.</p>",
      "sources": [
        {
          "title": "Informe original",
          "url": "https://example.com/report"
        }
      ],
      "disclosure": "Preparado con asistencia de IA y revisado por el equipo editorial."
    }
  ],
  "hasMore": false
}

02 / ACCESO CON INTENCIÓN

Eliges qué obtiene acceso.

Las claves pertenecen a un proyecto y actúan como cuentas de servicio. Elige solo los ámbitos que tu integración necesita. La expiración es opcional; la revocación se comprueba en cada solicitud.

Se aplican ámbitos, roles de servicio y límites de plan. Las acciones consecuentes como publicación, programación, eliminación y cambios administrativos también requieren concesiones explícitas del propietario desatendidas. OAuth personal no está disponible aún.

La publicación, el intercambio externo y las invitaciones también requieren que el creador de la clave de API tenga su correo verificado. Un 403 con email_unverified significa que esa persona debe verificar su correo en la plataforma antes de intentar de nuevo.

03 / LOS BLOQUES DE CONSTRUCCIÓN

Explora por lo que estás construyendo.

Explora 51 operaciones entre 10 áreas. Cada operación usa la misma estructura de ruta POST. El catálogo activo contiene los ámbitos exactos y esquemas de entrada.

Las operaciones sociales admiten perfiles y páginas de LinkedIn, Facebook, X, Threads, Instagram, Bluesky, TikTok y YouTube Shorts. Los publicaciones de TikTok y YouTube usan format: "video" y las publicaciones de TikTok también toman options.privacyLevel. Conectar una cuenta primero requiere consentimiento interactivo en Distribución. Las integraciones de boletines recopilan suscriptores; no envían campañas de correo.

API / TU CAPA DE PRESENTACIÓN

Traemos el contenido.
Tú construyes la experiencia.

Usa Endata como tu backend editorial y construye el front-end que tu audiencia necesita. Tu sitio web, aplicación o portal de cliente puede renderizar los mismos artículos aprobados con su propio diseño, navegación y marca.

04 / CONTENIDO QUE SE MANTIENE CONSISTENTE

Lee una edición, no un objetivo móvil.

Usa las rutas GET del artículo para entrega de contenido. Fija páginas posteriores en la primera respuesta de editionId, luego reemplaza tu contenido local solo después de que toda la actualización sea exitosa.

// Fija las páginas siguientes a la edición de la primera página.
// Reutiliza base, publication y headers de la guía rápida.
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.");
  }
}
// Reemplaza tu exportación anterior solo después de que todas las páginas lleguen bien.
// Una edición vacía obtenida con éxito significa que el contenido anterior debe eliminarse.

Los actualizaciones fallidas deben preservar tu exportación anterior. Una edición exitosa vacía debe eliminar contenido antiguo. Las ediciones retenidas más antiguas pueden permanecer legibles; la eliminación provisional no es borrado histórico.

05 / MÁS QUE UN FEED DE CONTENIDO

Haz que tu flujo de trabajo funcione para ti.

Prepara borradores, guarda revisiones, aprueba contenido revisado y pone en cola la publicación como operaciones distintas. La clave de solicitud de una escritura hace que los reintentos de red sean seguros sin repetir la mutación.

// Función auxiliar de operaciones en el servidor. Reutiliza una clave de solicitud solo con datos 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();
}
// Usa los ID reales de la noticia que ya revisaste.
await operation("story_approve", {
  postId: "STORY_UUID",
  revisionId: "REVIEWED_REVISION_UUID",
}, "approve-story-revision-001");

// Acción aparte y de consecuencias: requiere publishing:manage
// Y una autorización explícita del propietario para uso sin supervisión de la clave de servicio.
await operation("publication_publish", {}, "publish-edition-001");
// La publicación es asíncrona. Consulta publishing_read o recibe los eventos.

Este ejemplo extiende la base del inicio rápido de JavaScript, la publicación y los encabezados. Reemplaza los marcadores de posición UUID con IDs de historia y revisión reales. Un lote de publicación incluye todas las revisiones aprobadas elegibles y eliminaciones preparadas en la publicación, no solo una historia.

06 / SIGUE EL EVENTO

Presiona reproducir en todo el flujo.

Recorre la aprobación, publicación y entrega de webhook. Cambia de escenario para ver por qué un receptor necesita reintentos y protección contra duplicados.

07 / CUANDO ALGO CAMBIA

Verifica. Persiste. Reconoce.

Registra un punto final HTTPS bajo Configuración → Desarrollador → Webhooks. Elige eventos, guarda el secreto de firma cuando se emita, y verifica el cuerpo exacto de la solicitud antes de procesar.

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

// Pasa el cuerpo de la solicitud en UTF-8 exacto y sin modificar, junto con sus encabezados.
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);
}
// Tras la verificación, analiza y valida el evento.
// Guárdalo de forma atómica con una restricción de unicidad sobre Webhook-Id.
// Responde 2xx después de guardarlo; los eventos duplicados también deben responder 2xx.
// Procésalo de forma asíncrona y concilia el estado actual a través de la API.

Los eventos llevan IDs de recursos y metadatos de transición, no cuerpos de artículos. "edition.published" señala la activación de edición real. Tu receptor debe desencadenar su propia compilación o actualización; registrar un webhook no despliega tu sitio web.

08 / LISTO PARA EL MUNDO REAL

Prepárate para el problema ocasional.