Your content. Your tools. Go build something.

MEET YOUR NEXT CONNECTION

Give your AI tools
something to work with.

Put your AI client to work on your publication. MCP gives compatible clients tools to read content, inspect drafts, save revisions, and, with an explicit owner grant, queue publication.

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

CONNECT / STREAMABLE HTTP

Make the connection.

Connect a compatible MCP client using Streamable HTTP at https://app.endata.com/mcp. Tool schemas come from the same operation registry as the HTTP API.

The app calls this a project. API routes and request fields retain publication and publicationId; use those exact names in code.

Building an agent? Follow the step-by-step guide: Build an automated content pipeline with the MCP server.

Codex

Add this to ~/.codex/config.toml. Make your project API key available as ENDATA_API_KEY in the environment that starts Codex.

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

Claude Code

Add this to your project’s .mcp.json. Set ENDATA_API_KEY in the environment before starting Claude Code. Keep the key itself out of configuration files and source control.

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

These examples use the clients’ documented HTTP MCP configuration. Connection and available tools depend on your key’s scopes and project permissions.

Build your own MCP client

// Node.js with @modelcontextprotocol/sdk installed.
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();
}

This uses the official MCP TypeScript SDK, not an Endata-specific SDK. Configure bearer credentials through your client’s secure connection settings. API-key connections are supported; personal OAuth and client registration are deferred.

01 / YOUR FIRST REQUEST

Grab a key. Get some content.

Create a project API key in Settings → Developer → API Keys. Start with published:read and run your first request on a server or in your build environment.

// Server-side JavaScript. Keep credentials out of browser bundles.
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": "Industry Brief",
    "slug": "industry-brief"
  },
  "editionId": "EDITION_UUID",
  "items": [
    {
      "id": "ARTICLE_UUID",
      "slug": "a-new-perspective",
      "title": "A new perspective on your industry",
      "summary": "The developments that matter, with your editorial context.",
      "body": "<p>Reviewed article content.</p>",
      "sources": [
        {
          "title": "Original report",
          "url": "https://example.com/report"
        }
      ],
      "disclosure": "Prepared with AI assistance and reviewed by the editorial team."
    }
  ],
  "hasMore": false
}

02 / ACCESS WITH INTENTION

You choose what gets access.

Keys belong to one project and act as service accounts. Choose only the scopes your integration needs. Expiration is optional; revocation is checked on every request.

Scopes, service roles, and plan limits all apply. Consequential actions such as publishing, scheduling, deletion, and administrative changes also require explicit owner unattended grants. Personal OAuth is not available yet.

Publishing, external sharing, and invitations also require the API key creator’s verified email. A 403 with email_unverified means that person must verify their email in the platform before retrying.

03 / THE BUILDING BLOCKS

Explore by what you’re building.

Explore 77 operations across 12 areas. Every operation uses the same POST route structure. The live catalog contains the exact scopes and input schemas.

Social operations support LinkedIn profiles and Pages, Facebook, X, Threads, Instagram, Bluesky, TikTok and YouTube Shorts. TikTok and YouTube posts use format: "video", and TikTok posts also take options.privacyLevel. Connecting an account first requires interactive consent in Distribution. Newsletter integrations collect subscribers; they do not send email campaigns.

API / YOUR PRESENTATION LAYER

We bring the content.
You build the experience.

Use Endata as your editorial backend and build the front end your audience needs. Your website, app, or customer portal can render the same approved articles with its own layout, navigation, and brand.

04 / CONTENT THAT STAYS CONSISTENT

Read an edition, not a moving target.

Use the article GET routes for content delivery. Pin subsequent pages to the first response’s editionId, then replace your local content only after the entire refresh succeeds.

// Pin subsequent pages to the first page's edition.
// Reuse base, publication and headers from the quick start.
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.");
  }
}
// Only replace your previous export after every page succeeds.
// A successful empty edition means the old content should be removed.

Failed refreshes should preserve your previous export. A successful empty edition should remove old content. Older retained editions can remain readable; staged unpublishing is not historical erasure.

05 / MORE THAN A CONTENT FEED

Make your workflow work for you.

Prepare drafts, save revisions, approve reviewed content, and queue publishing as distinct operations. A write’s request key makes network retries safe without repeating the mutation.

// Server-side operation helper. Reuse a request key only for identical input.
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 actual IDs from the article you have reviewed.
await operation("article_approve", {
  articleId: "ARTICLE_UUID",
  revisionId: "REVIEWED_REVISION_UUID",
}, "approve-article-revision-001");

// Separate, consequential action: requires publishing:manage
// AND an explicit owner unattended grant for the service key.
await operation("publication_publish", {}, "publish-edition-001");
// Publishing is asynchronous. Poll publishing_read or receive events.

This example extends the JavaScript quick start’s base, publication, and headers. Replace UUID placeholders with actual article and revision IDs. A publishing batch includes all eligible approved revisions and staged removals in the publication—not just one article.

06 / FOLLOW THE EVENT

Press play on the whole flow.

Walk through approval, publishing, and webhook delivery. Switch scenarios to see why a receiver needs retries and duplicate protection.

07 / WHEN SOMETHING CHANGES

Verify. Persist. Acknowledge.

Register an HTTPS endpoint under Settings → Developer → Webhooks. Choose events, save the signing secret when it is issued, and verify the exact request body before processing.

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

// Pass the exact, unmodified UTF-8 request body and request headers.
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);
}
// After verification, parse and validate the event.
// Atomically persist it with a unique constraint on Webhook-Id.
// Return 2xx after persistence; duplicate events should also return 2xx.
// Process asynchronously and reconcile current state through the API.

Events carry resource IDs and transition metadata, not article bodies. “edition.published” signals actual edition activation. Your receiver must trigger its own build or refresh; registering a webhook does not deploy your website.

08 / READY FOR THE REAL WORLD

Plan for the occasional hiccup.