Put your content workflow
within reach of your AI tools.

THE STAR OF YOUR TOOLCHAIN

An AI assistant that can
work with your project.

Move beyond copying text between windows. MCP gives a compatible AI client structured tools: read content, inspect drafts, save revisions, and—with an explicit owner grant—queue publication.

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

CONNECT / STREAMABLE HTTP

Your project. Connected to your tools.

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.

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: "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 / CONNECT YOUR PROJECT

From key to 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

Give each integration its own boundaries.

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 51 operations across 10 areas. Every operation uses the same POST route structure. The live catalog contains the exact scopes and input schemas.

Social operations support LinkedIn and Bluesky. Connecting an account first requires interactive consent in Distribution. Newsletter integrations collect subscribers; they do not send email campaigns.

API / YOUR PRESENTATION LAYER

Your content is the constant.
The experience is yours.

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

Build around editorial decisions.

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 story you have reviewed.
await operation("story_approve", {
  postId: "STORY_UUID",
  revisionId: "REVIEWED_REVISION_UUID",
}, "approve-story-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 story and revision IDs. A publishing batch includes all eligible approved revisions and staged removals in the publication—not just one story.

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

Make the unhappy path predictable.