Menu
Mattering Automations connector

A Storyblok MCP for content workflows that reach past the CMS

Connect one personal access token and stories, components, datasources, assets, and releases become workflow steps. An AI agent can draft a story and wait for a human approval before publishing, a datasource entry can act as remote configuration your frontend reads without a deploy, and a release can bundle a batch of changes that goes live together.

45 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Storyblok MCP connector does

The Storyblok connector for Mattering Automations is 45 nodes across the Storyblok Management API: stories with the full create, update, publish, unpublish, and delete lifecycle, components and their field schemas, datasources and their key and value entries, assets and asset folders with metadata editing, releases that batch story changes and deploy them together, plus reads for tags, workflows, workflow stages, tasks, presets, and space roles. One personal access token, stored with the region its spaces are hosted in, authenticates all of it.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can list a space's stories, fetch one with its full content object, edit it, send it back as a draft, and leave the publish decision to a human, without anyone opening the Storyblok app.

Storyblok hosts an official MCP server of its own at mcp.labs.storyblok.com, and it does what it says: it exposes the Management API to MCP-compatible clients, so if all you want is an assistant talking directly to Storyblok, it is the natural first stop. This connector is for the other half of the job, where Storyblok is one step among many. On the Mattering canvas the same nodes sit next to every other connector and the platform itself, so a drafted story can wait behind an approval task before it publishes, a component schema audit can write what it finds into a Mattering database, and a release deploy can sit at the end of a workflow instead of at someone's fingertips. Use whichever fits, or both.

The safety modeling is stated plainly. Of the 45 nodes, 19 read and 26 act, and eight are flagged destructive: the story, component, component folder, asset, asset folder, datasource, datasource entry, and release deletes, each of which tells you to capture the object first. Two update rules are written on the nodes rather than left to be discovered: a story's content object and a component's schema are replaced whole on update, so the loop is always read, edit, send the full object back. And one seam is admitted up front: Storyblok's asset upload is a three-step signed flow, the init and finish steps are nodes, and the middle step, posting the file bytes to the signed S3 URL, must run outside the canvas.

One connection, three surfaces

  • Visual automations. Drag Storyblok nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Storyblok node, ready to drop on the canvas

45 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 19

Storyblok: Get Asset

Fetch one asset: CDN filename URL, content type and size, metadata (alt, title, copyright), folder, and privacy flag.

Storyblok: Get Component

Fetch one component with its full schema definition - the read to do before Update Component, since the schema is replaced whole.

Storyblok: Get Space

Fetch one space with its full detail: domain, environments, plan, roles, and settings (more properties than the list endpoint returns).

Storyblok: Get Story

Fetch one story fully loaded, INCLUDING its content object (the list endpoint omits content). The read to do before an update, since updates send the whole content object back.

Storyblok: List Asset Folders

List the space's asset folders (nested via parent_id) with the numeric IDs the asset nodes use.

Storyblok: List Assets

List a space's assets with filters on filename, folder, alt text, title, copyright, and tags. Returns the numeric asset IDs used by the get, update, and delete nodes.

Storyblok: List Component Folders

List the space's component folders (component groups) with both identifiers each carries: the numeric id (path parameter for folder endpoints) and the uuid (what a component's component_group_uuid references).

Storyblok: List Components

List a space's components (block definitions) with their numeric IDs and full field schemas, plus the space's component folders in the same response (data.component_groups).

Storyblok: List Datasource Entries

List a datasource's key/value entries. Select the datasource by numeric ID or slug (pagination is disabled when selecting by slug); pass a dimension ID to get each entry's dimension_value.

Storyblok: List Datasources

List the space's datasources (named key/value collections) with their numeric IDs, slugs, and dimensions.

Storyblok: List Presets

List the space's component presets (pre-filled block values editors can insert), optionally filtered to one component.

Storyblok: List Releases

List the space's releases (scheduled content batches) with their numeric IDs, scheduled release_at time, and whether each has been released.

Storyblok: List Space Roles

List the space's custom roles with their permission sets and allowed content paths (useful for access audits).

Storyblok: List Spaces

List the spaces the personal access token can access, with their numeric IDs, plan, and hosting region. Every other Storyblok node needs a space ID from here. Also the credential health check: a bad token returns 401. Note a token only sees spaces in the credential's region.

Storyblok: List Stories

List a space's stories (content entries) WITHOUT their content field, with filters on slug, tag, folder, publish state, release, and a content-wide text search. Returns the numeric story IDs used by the get, update, publish, and delete nodes.

Storyblok: List Tags

List the space's story tags with usage counts. Tag NAMES (not ids) are what stories carry in tag_list and what the with_tag filter takes.

Storyblok: List Tasks

List the space's tasks - user-triggerable webhook calls (build triggers, syncs) defined in the space's settings.

Storyblok: List Workflow Stages

List the space's workflow stages (the steps stories move through) with their numeric IDs - the values the story lister's in_workflow_stages filter takes.

Storyblok: List Workflows

List the space's content workflows with their numeric IDs and the content types each applies to.

Action nodes 26

Storyblok: Create Asset Folder

Create an asset folder, optionally nested under a parent. Reversible with Storyblok: Delete Asset Folder.

Storyblok: Create Component

Create a component (block definition). schema is a key-value object of field definitions, each with at least a type. Reversible with Storyblok: Delete Component.

Storyblok: Create Component Folder

Create a component folder for organizing block definitions. Reversible with Storyblok: Delete Component Folder.

Storyblok: Create Datasource

Create a datasource (a key/value collection usable in component options and via the Content Delivery API). Reversible with Storyblok: Delete Datasource.

Storyblok: Create Datasource Entry

Add a key/value entry to a datasource. Reversible with Storyblok: Delete Datasource Entry.

Storyblok: Create Release

Create a release: a named batch that story changes can be saved into (via the story nodes' release_id) and deployed together, optionally scheduled. Reversible with Storyblok: Delete Release while undeployed.

Storyblok: Create Story

Create a story (or folder) in a space. The content object must carry a component property naming its content type, and every nested component block needs a _uid. Created as a draft unless publish is set. Reversible with Storyblok: Delete Story.

Storyblok: Delete Asset

DESTRUCTIVE: delete an asset. Stories referencing its CDN URL will show a broken file. Capture the asset object first with Storyblok: Get Asset if there is any doubt.

Storyblok: Delete Asset Folder

DESTRUCTIVE: delete an asset folder. The assets themselves are not deleted, but their folder organization is lost.

Storyblok: Delete Component

DESTRUCTIVE: delete a component definition permanently. Stories already using it keep their stored data but the block becomes undefined in the editor. Capture the schema first with Storyblok: Get Component.

Storyblok: Delete Component Folder

DESTRUCTIVE: delete a component folder (uses the NUMERIC folder id, not the uuid). Components in it are not deleted, only un-grouped.

Storyblok: Delete Datasource

DESTRUCTIVE: delete a datasource and EVERY entry in it, permanently. Export the entries first with Storyblok: List Datasource Entries if there is any doubt.

Storyblok: Delete Datasource Entry

DESTRUCTIVE: delete one key/value entry from a datasource. Frontends reading the key get nothing back.

Storyblok: Delete Release

DESTRUCTIVE: delete a release. Story changes saved into it (and its schedule) are discarded rather than deployed.

Storyblok: Delete Story

DESTRUCTIVE: delete a story. It stops being delivered immediately and the docs make no promise an API delete is recoverable - capture it first with Storyblok: Get Story if there is any doubt. Deleting a folder affects its children.

Storyblok: Finish Asset Upload

Step 3 of the asset upload: finalize an upload after the file bytes were POSTed to the signed S3 post_url (externally - see Init Asset Upload). The asset becomes visible in the space afterwards.

Storyblok: Init Asset Upload (Signed Request)

Step 1 of Storyblok's 3-step asset upload: request a signed S3 upload. Returns post_url and a fields object. Step 2 - POSTing the file bytes to post_url as multipart/form-data with every fields entry - must happen OUTSIDE the canvas (a worker or script); then run Storyblok: Finish Asset Upload with the returned id. Reversible with Storyblok: Delete Asset once finished.

Storyblok: Publish Story

Publish a story's current draft, making it live on the published version delivered to frontends. Storyblok models this as a GET with side effects. Reversible with Storyblok: Unpublish Story.

Storyblok: Unpublish Story

Unpublish a story: it disappears from the published version frontends deliver (the draft is kept). Storyblok models this as a GET with side effects. Reversible with Storyblok: Publish Story.

Storyblok: Update Asset

Update an asset's METADATA: alt text, title, copyright, source (via the meta_data object), move it to a folder, or toggle privacy/lock. To replace the file bytes use the upload flow, not this node. Only fields you fill are sent.

Storyblok: Update Asset Folder

Rename an asset folder or move it under a different parent. Only fields you fill are sent.

Storyblok: Update Component

Update a component definition. The schema object is REPLACED whole when sent - read it first with Storyblok: Get Component and send the full edited schema, or leave schema blank to keep it. A schema change affects every story using the component.

Storyblok: Update Datasource

Rename a datasource or change its slug. Changing the slug breaks frontends fetching entries by the old slug.

Storyblok: Update Datasource Entry

Update an entry's key or value - the remote-config move: flip a value a frontend reads through the datasource. To set a per-dimension value, send dimension_value together with the dimension_id it belongs to. Only fields you fill are sent.

Storyblok: Update Story

Update a story. IMPORTANT: content is REPLACED whole, not merged - read the story first with Storyblok: Get Story, modify its content object, and send it back. Only fields you fill are sent. publish=true publishes the result; false saves a draft without unpublishing.

Storyblok: Update or Deploy Release

Update a release (rename, reschedule) or DEPLOY it now by setting do_release. Deploying publishes every story change in the release immediately and there is no single undo - reverting means unpublishing or re-editing each story. Test runs must leave do_release blank.

Connecting Storyblok takes one credential

Storyblok authenticates Management API requests with a personal access token, created in the Storyblok app under My account, then Account settings, then Personal access tokens. A token grants access to the spaces you own by default and can be restricted to specific spaces with per-scope permissions covering stories, components, assets, datasources, and more. One detail matters as much as the token itself: Storyblok hosts spaces in regions (EU by default, plus US, Canada, Asia-Pacific, and China), the Management API host depends on the space's region, and a token only works against its own region's host. The Mattering credential stores the token together with its region, and an organization with spaces in more than one region needs one connection per region.

1

Sign in to the Storyblok app, open My account, then Account settings, then Personal access tokens, and generate a new token. Restrict it to the spaces your workflows touch if you do not want it covering every space you own.

2

Note which region your spaces are hosted in. The hosting region decides which API host the token works against, and a wrong region fails exactly like a wrong token.

3

In Mattering Automations, open Connectors, click Add Connector, choose Storyblok, and create a credential with the personal access token and the region. Leave the region blank for EU, the default.

4

Click Test Connection. Mattering lists the spaces the token can see on its regional host: a success proves both the token and the region, a 401 means one of the two is wrong.

5

All 45 Storyblok nodes appear in the canvas palette. Run Storyblok: List Spaces first: every other node needs a space ID from it, and a token only sees spaces in its own region.

Common uses for the Storyblok MCP

Publishing that waits for a human

Storyblok: Create Story writes a draft, complete with its component-typed content object, and the workflow opens an approval task in Mattering Productivity instead of publishing immediately. On approval, Storyblok: Publish Story makes it live, and because Storyblok: Unpublish Story reverses it exactly, the whole play stays undoable. The publish flag on the create and update nodes exists for the flows that have earned the right to skip the gate.

An AI agent that edits content with a read-first habit

A story's content object is replaced whole on update, not merged, so the safe loop is fixed: Storyblok: Get Story fetches the story fully loaded (the list node deliberately omits content), the agent edits the object, and Storyblok: Update Story sends the whole thing back. Sending a partial content object deletes the missing fields, which is why the node itself says to read first. The same rule holds for component schemas via Storyblok: Get Component and Storyblok: Update Component.

Datasource entries as remote configuration

A Storyblok datasource is a named key and value collection frontends can read, which makes Storyblok: Update Datasource Entry the remote config move: a workflow flips a value and the site picks it up without a deploy. Storyblok: List Datasource Entries exports the current state first, per-dimension values ride along when you send dimension_value with its dimension_id, and Storyblok: Create Datasource Entry grows the collection one key at a time.

Release trains instead of one-off publishes

Storyblok: Create Release makes a named batch, story changes save into it through the story nodes' release_id, and the batch goes live together: at its scheduled release_at time, or when Storyblok: Update or Deploy Release runs with do_release set. Deploying publishes every story change in the release at once and there is no single undo, so the node warns loudly and belongs behind an approval step, never a bare trigger.

Asset metadata sweeps

Storyblok: List Assets filters a space's media by filename, folder, alt text, title, copyright, and tags, and Storyblok: Update Asset fixes what it finds: alt text for accessibility, copyright lines, titles, folder moves, and privacy flags, sending only the fields you fill. One honest boundary: replacing file bytes is a three-step signed upload whose middle step runs outside the canvas, so metadata is the surface a scheduled sweep can own end to end.

Component schema audits that land in a database

Storyblok: List Components returns every block definition with its full field schema in one call, and a scheduled sweep can write the inventory into a Mattering database and open a task when a schema drifted from the design system. Before any schema change, Storyblok: Get Component captures the current definition, which doubles as the backup the destructive Storyblok: Delete Component node tells you to take.

Example: A drafted article goes live: create the story, wait for approval, publish, record it

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: an inbound webhook from your editorial pipeline fires with a finished draft, its target folder, and its content type.

2

Storyblok: Create Story writes the draft into the space. The content object names its component, and the story stays a draft because publish is left unset.

3

The workflow opens an approval task in Mattering Productivity with the story's name, slug, and space, so an editor reviews it in the Storyblok visual editor.

4

On approval, Storyblok: Publish Story makes the story live on the published version frontends deliver.

5

Storyblok: Update Story adds the campaign tag to tag_list, sending only that field, so the content object is untouched.

6

The workflow writes the story ID, publish time, and approver into a Mattering database, an audit trail that lives next to the rest of the work.

Storyblok MCP questions, answered

What Storyblok operations are supported?

45 nodes on the Storyblok Management API: 19 query nodes and 26 action nodes covering spaces (list and get), stories (list, get, create, update, publish, unpublish, delete), components and component folders, assets and asset folders including the signed upload's init and finish steps, datasources and datasource entries, releases including deploy, and reads for tags, workflows, workflow stages, tasks, presets, and space roles. Deliberately not shipped: the asset upload's middle step of posting file bytes, statistics endpoints, webhook and collaborator administration, pipelines and branches, and standalone tag writes, since tags are created implicitly by writing tag_list on a story.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively.

Storyblok has an official MCP server. Why use this connector?

Storyblok's own MCP server at mcp.labs.storyblok.com exposes the Management API to MCP-compatible clients, and if all you want is an assistant with a direct line to Storyblok, it is a genuine option. This connector earns its place when Storyblok is one step in a larger workflow: the same canvas holds your other connectors and the Mattering platform itself, so a drafted story can wait behind a human approval task before publishing, a schema audit can write into a database next to the rest of your work, and a release deploy can be the gated last step of a pipeline. Credentials live in one place with the rest of your connector secrets, and the same nodes serve visual automations and AI agents alike.

What are Storyblok's API rate limits?

Storyblok documents Management API rate limits by plan: 3 requests per second on the Starter plan and 6 requests per second on Growth, Growth Plus, Premium, and Elite. Exceeding them returns HTTP 429, and the nodes report the 429 on their output rather than silently retrying, so pace wide sweeps, prefer one filtered List call over many Get calls, and add wait steps between batches.

Can an AI agent publish and unpublish stories safely?

That is one of the connector's designed-for jobs, and the pairing is what makes it safe: Storyblok: Publish Story and Storyblok: Unpublish Story reverse each other exactly, and unpublishing keeps the draft. The honest pattern is to create or update as a draft, put a human approval task between the draft and the publish step, and keep the publish flag off the create and update nodes until a flow has earned it. The one loud moment is release deploy, which publishes every story change in a release at once with no single undo, so it stays behind approvals.

My token is correct but every node returns 401. Why?

Check the region before regenerating the token. Storyblok serves the Management API from a different host per region (EU by default, plus US, Canada, Asia-Pacific, and China), a token only works against its own region's host, and a wrong region produces the same 401 as a wrong token. The Mattering credential carries the region alongside the token, and an organization with spaces in more than one region needs one connection per region.

Can an automation upload files to Storyblok?

Partially, and the boundary is stated rather than hidden. Storyblok's asset upload is a three-step signed flow: Storyblok: Init Asset Upload (Signed Request) requests the signed S3 upload and returns a post_url with form fields, the file bytes must then be posted to that URL as multipart form data outside the canvas (a worker or script), and Storyblok: Finish Asset Upload finalizes it so the asset appears in the space. What the canvas owns end to end is everything after the bytes exist: listing, fetching, metadata editing with Storyblok: Update Asset, folder organization, and deletion.

What is deliberately not included?

Each omission has a stated reason. The asset upload's middle step: posting raw file bytes with dynamic form fields is not something a canvas node can author safely, so that leg runs in a worker or script between the init and finish nodes. Statistics endpoints: Storyblok's traffic reporting is a separate windowed surface outside this cut. Account administration: collaborators, webhooks, pipelines and branches, field plugins, and extensions are configuration surfaces, not automation steps. Standalone tag writes: tags are created implicitly by writing tag_list on a story, which the story nodes already do. Workflow, task, preset, and space role writes: the reads are built for audits and for the IDs the story filters take, and the configuration stays in the Storyblok app.

45 nodes waiting on the canvas

Put Storyblok to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Storyblok is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products