7.4 · Connect Strapi
When to connect your Strapi instance to GrowthOS, the custom API token to create (with the exact permissions), and the setup wizard from connection to first published draft.
GrowthOS can publish finished articles straight into your Strapi instance: pick a collection type, click publish, and the article lands as a Strapi draft with formatting intact and images in your media library. The connection is a one-time setup of about five minutes; the token permissions are the only fiddly part, and this guide lists them exactly. It covers when you need it, what to gather before you start, the setup wizard step by step, and what publishing looks like once it's live.
When to connect
Connect Strapi as soon as your workspace is producing articles that end up on your Strapi-powered site. The signals that it's overdue:
- Someone is copy-pasting. Articles are finished in GrowthOS, then manually recreated in the Strapi admin: headings rebuilt, images re-uploaded through the media library, meta fields retyped. Every article costs 15 to 30 minutes of pure transcription, and every transcription is a chance to drift from the reviewed version.
- Formatting keeps breaking in the move. Lists lose structure, links drop, or rich-text content pastes as one flat block. The publishing pipeline writes your body field in its native format, so this whole class of problem disappears.
- Publishing volume is ramping. Moving from a couple of articles a month to a weekly cadence makes the copy-paste tax immediate. Connect before the ramp, not after.
If your site is not on Strapi, the same flow exists for Webflow, Sanity, and WordPress; only the credentials step differs. And with no connection at all, GrowthOS still supports manual publishing (mark the article published and paste the live URL), so nothing blocks while you wait on access.
What you'll need
- A Strapi v5 instance and admin access to it, enough to create an API token under Settings.
- A GrowthOS login that can manage publishing. If you don't see CMS Connections under Workspace Admin, ask your GrowthX team to enable it.
- Five minutes with both tabs open.
How to connect
Create a custom API token in Strapi
In your Strapi admin, go to Settings → API Tokens and create a token with token type Custom. The Read-only and Full access presets won't work: Read-only can't write articles, and presets don't carry the schema-reading permission GrowthOS needs. Grant the custom token exactly this:
- The collection type you publish into (for example Article): find, findOne, create, update, delete
- Any collection type its relations point at (for example Category or Author): find, findOne
- Upload: upload, find, destroy
- Content-type-builder: getContentTypes
The last one is the easy miss: it's what lets GrowthOS read your content structure to build the field mapping. Copy the token when Strapi shows it; it appears only once.
Connect the CMS in GrowthOS
In GrowthOS, go to Workspace Admin → CMS Connections and click Connect a CMS. Pick Strapi from the cards and fill in the form:
- Strapi URL: your instance's address, for example
https://cms.example.com(pasting the/adminlink works too). - API token: the custom token from step 1.
- Public site URL (optional): your website's address. Strapi never knows your page URLs, so a published article's link is this URL plus its slug; without it, GrowthOS can't hand you a working live link.
Leave the live-publishing switch off for now; it's the right default, and you can flip it later from this same screen once you trust the pipeline (see how publishing works).
Submitting lands you on the connection's settings screen, and GrowthOS immediately reads your instance's collection types. Within a few moments the header fills in with how many it found. If your content structure changes later, Re-read refreshes the picture without disturbing anything already set up.
Add the blog collection type
Click Add a collection type and pick the one your articles live in (usually Article or Post). The dialog lists your collection types (single types aren't publish targets) and warns you if the one you picked has no rich-text field, which usually means it's the wrong one. Confirming opens that collection type's setup wizard.
Review and confirm the field mapping
GrowthOS proposes a mapping from its article fields (title, slug, body, meta title, meta description, cover image) to the collection type's fields, with a reason for each suggestion. Review it in the confirm form: required fields are listed first and marked, each field has a source picker, and anything GrowthOS shouldn't touch can be left unmapped or given a fixed value. If your collection type has a required relation (say every article needs a Category), you pick the entry it should point at right here. The form blocks you if a required field is uncovered or the article body has no home, so you can't confirm a broken mapping.
Run the test article
The wizard stages a sample article in your instance as a draft, then shows you exactly what Strapi received, field by field, with a link that opens the real entry in your admin. This is your proof the mapping works before any real content moves. Check that the body kept its structure (headings, lists, links) and that every mapped field carries the right value.
Finish
The last step recaps the collection type, the mapping, and the test round trip. Finishing marks the collection type ready and deletes the sample draft from your instance, so nothing is left behind. You can add more collection types to the same connection later; each gets its own mapping and its own wizard pass.
How publishing works after setup
Every article in GrowthOS now has a working Publish step. Pick the collection type, publish, and watch the card update as the article lands.
- Draft first, always. Publishing writes the entry's draft version, using Strapi v5's native draft-and-publish. If the article is already live, your published version stays untouched until the draft is promoted, relations and all. Promoting from GrowthOS only works when the connection's live-publishing switch is on (it starts off); until then, going live happens in the Strapi admin on your terms.
- Updates flow through the same button. Edit the article in GrowthOS and publish again; the existing entry is updated in place. Republishing an unchanged article does nothing rather than creating a duplicate.
- Images live in your media library. Inline images and the cover upload to Strapi's media library and the entry references them there. The published page never loads assets from GrowthOS, and republishing reuses the files already uploaded instead of duplicating them.
- The body arrives in your field's native format. A classic rich-text field gets markdown; a blocks field gets native block content. Either way your frontend renders it the way it renders everything else.
Known limitations
- Tables in a blocks field become code blocks. Strapi's block format has no table element, so a table arrives as a code block holding the table's text: readable and recoverable, but not rendered as a table. Classic rich-text fields don't have this problem, since markdown tables pass straight through.
- Component and dynamic-zone fields are never written. Writing part of a component or dynamic zone would replace your whole structure, so GrowthOS leaves those fields alone; they show as "Managed in Strapi" in the mapping. Keep managing them in the Strapi admin.
- Strapi v5 only. The connection speaks Strapi 5's API. A v4 instance needs upgrading before it can connect.
Troubleshooting
- The connect step rejects the token. Almost always a preset token instead of a custom one, or a custom token missing a permission from the checklist above (Content-type-builder's getContentTypes is the usual gap). Recreate the token with the exact list and paste it again.
- Articles publish but images fail. The token is missing the Upload permissions. Edit the token to add upload, find, and destroy under Upload, then republish; the entry itself doesn't need to be recreated.
- A publish is refused because the collection type changed. Someone changed the content structure in Strapi, and GrowthOS pauses that collection type rather than publish into a structure it no longer recognizes. Open the collection type in CMS Connections and re-run the mapping against the refreshed schema; other collection types on the connection keep publishing throughout.
Where to go next
Last updated at August 19, 2026