Connect Strapi to Relato with the Strapi MCP

It's a hands-off way to keep your CMS in sync with your editorial workflow. You write and review in Relato. The agent does the publishing.

What you need before you start

A running Strapi instance with the Strapi MCP server enabled and reachable from the internet.
An admin role in the Relato organization where you want the integration to live.
A workspace in that organization with a stage named "Ready to publish" (or whatever you'd like to use as the trigger).
A clear mapping between your Relato project fields and your Strapi collection fields. The agent will use this as its source of truth.

Step 1: Add Strapi as an MCP account in Relato

In Relato, open Settings for your organization, then go to Integrations.
Find MCP in the integrations list and click Add account.
Paste the MCP URL of your Strapi instance (your Strapi admin will know this — it usually looks like https://your-strapi.example.com/mcp).
Approve the OAuth prompt that opens. You'll be asked to sign in to Strapi and confirm the connection.
Give the account a clear display name. This name will prefix every Strapi tool in the agent tool picker (for example, [Strapi Production] createEntry), so pick something you'll recognise later.

Once connected, Relato discovers the tools the Strapi MCP server exposes and makes them available to agents in your organization. You can edit the URL or revoke the account from the same Integrations page at any time.

Step 2: Create the publishing agent

From the AI Content Agents area, create a new agent. A blank agent is fine.
Give it a name like Publish to Strapi and a short description.
In the agent's Tools picker, attach the Strapi MCP tools you want it to use. At minimum you'll want a tool that can create or update an entry in your target collection. Tools from your MCP account are listed under the prefix you set in step 1.
While you're in the picker, also attach the Relato query and project tools the agent will need to read the project it's working on. Useful ones include the project query, asset query, and any Google Workspace tools if your drafts live in Google Docs.

Step 3: Trigger the agent on stage change

In the agent's Triggers settings, add a new event trigger.
Choose the Project stage changed event.
Set the agent's Scope to the workspace where your drafts live, so the agent only fires for projects in that workspace.

A note about how this trigger works: Project stage changed fires for every stage transition in the scoped workspace, not just transitions into a specific stage. The "only act when the project reaches Ready to publish" check happens inside the agent's prompt, in the next step. That's deliberate — it keeps the trigger configuration simple and the routing logic visible in one place.

Step 4: Tell the agent what to do

Open the agent's instructions and paste a short prompt that describes the publishing job. The agent needs three things from you: the target Strapi collection, the field mapping, and the rules for handling edge cases.

Here's a starting template you can adapt:

You are responsible for publishing a Relato project to Strapi when it

reaches the "Ready to publish" stage.

On each run:

1. Read the project that triggered the run. If its current stage is

anything other than "Ready to publish", stop immediately and do

nothing — this run was triggered by a different stage transition.

2. Pull the project's title, summary, content type, labels, SEO fields

(seoTitle, seoDescription, seoKeywords), and any linked Google Docs

or asset URLs.

3. If a Google Doc is attached, fetch its current content.

4. Build a Strapi entry in the "articles" collection with this mapping:

- Relato project.title -> Strapi title

- Relato project.summary -> Strapi excerpt

- Relato seoTitle -> Strapi seo.metaTitle

- Relato seoDescription -> Strapi seo.metaDescription

- Relato project.contentType -> Strapi category (match by name)

- Relato project.labels[] -> Strapi tags[] (match by name)

- Google Doc body -> Strapi body (as HTML)

5. Call the Strapi MCP tool to create the entry as a draft.

6. Post a comment on the Relato project with the Strapi entry URL once

the publish succeeds.

Rules:

- If a project has already been published (look for a "Strapi entry" link

in the project URLs), update the existing Strapi entry instead of creating

a duplicate.

- If a required field is missing on the Relato side, stop, post a comment

explaining which field is missing, and do not call Strapi.

- If Strapi rejects the entry, post the error as a comment on the project

and do not retry automatically.

Adapt the field mapping to your collection. The shape of this prompt is intentional: read the project, fetch its content, build the entry, call the Strapi tool, leave a breadcrumb on the project. Keep edge cases explicit.

Step 5: Test with a single project

Before you turn this loose on your whole pipeline, run it once end to end:

Pick a single project in the target workspace that's safe to publish (or use a sandbox Strapi collection).
Move it to the "Ready to publish" stage.
Watch the agent's thread. It will show you each tool call, including the Strapi tool, with the entry payload.
Check the result in Strapi.
Move the project back out of the stage and repeat with adjustments to the prompt or field mapping if anything looks off.

Once a test pass works cleanly, leave the agent enabled. It will fire automatically on every future stage transition.

Tips

Publish as draft first. Have the agent create entries in Strapi as drafts, not published, until you trust the workflow. Many Strapi MCP servers expose a separate publish tool you can wire up as a second agent or a manual step.
Use one MCP account per Strapi environment. Add separate accounts for staging and production with different display names. That way the agent picker shows [Strapi Staging] and [Strapi Production] and you can route different workspaces to different environments.
Keep the prompt boring. The mapping rules are the value. Describe them precisely, list every field, and spell out what to do when a field is empty. Save the cleverness for the writing, not the wiring.

FAQ

Does this work with self-hosted Strapi only, or Strapi Cloud too?

Both, as long as the Strapi MCP server is reachable from Relato and supports OAuth. The Relato side doesn't care where Strapi is hosted.

What if my Strapi MCP uses an API token instead of OAuth?

The Relato MCP integration is OAuth-based. If your Strapi MCP only supports API tokens, you'll need to put an OAuth proxy in front of it or wait for the Strapi MCP server to support the OAuth profile that Relato expects.

Can the agent both create and update Strapi entries?

Yes, as long as the Strapi MCP server exposes both create and update tools, and you describe in the agent prompt how to choose between them. The recommended pattern is: store the Strapi entry URL or ID on the Relato project after the first publish, then check for it on subsequent runs.

What happens if the agent run fails?

The agent will not retry on its own. The project stays in "Ready to publish" stage. Look at the agent thread to see what went wrong. Adjust the prompt or the field mapping and move the project out of and back into the stage to retrigger.

How do I revoke the Strapi MCP connection?

Open Integrations, find the MCP account, and choose Revoke. Agents that were using its tools will lose access to those tools immediately.