How to schedule and publish content automatically in Contentful

If you've ever needed to launch a blog post at 3 a.m. or push out an announcement over the weekend, you know the pain of manual publishing. This guide is for folks who use Contentful—marketers, editors, developers, or anyone tired of watching the clock for that perfect publish moment. We’ll cut through the fluff and get you set up to schedule and automate your content, with honest advice for what actually works.

Why Bother Scheduling Content in Contentful?

Let’s be real: Contentful is a rock-solid headless CMS, but it’s not a full-fledged marketing platform with built-in campaign schedulers. By default, content has to be published by hand. That’s fine for some, but if you want to:

Launch content at specific times (think: embargoes, events, or time zones),
Batch work ahead of time,
Or avoid last-minute publishing scrambles,

…then scheduling is a must. The catch is, Contentful doesn’t have scheduling “out of the box.” But you can get there—if you’re willing to set up some automation.

The Honest Truth: What Scheduling in Contentful Actually Looks Like

Before you dive in, here’s what you should know:

No native scheduling feature. There’s no big red “schedule” button. You’ll need to set up a workaround.
You’ll need to be comfortable with webhooks or external tools. If you’re allergic to automation scripts or third-party services, it’s going to be tricky.
The Editorial Calendar app is… limited. It looks nice but just visualizes dates—you can’t actually schedule publishing.

In short: scheduling is possible, but it’s not just a checkbox. Let’s get you set up.

Step 1: Understand How Contentful Handles Publishing

Contentful separates “draft” and “published” states. When you click “Publish” in the web app, that entry goes live immediately in your delivery API. There’s no built-in way to set a future publish date.

Workaround: You’ll need to store a “publish at” timestamp in your entries. Then, use automation to check for entries that should go live and trigger publishing at the right time.

Step 2: Add a “Publish At” Field to Your Content Model

You’ll need a place to store when each entry should be published.

How to do it:

Go to your Content Model in Contentful.
Edit the relevant content type (e.g., “Blog Post”).
Add a new field:
Type: Date and time
Name: publishAt (or whatever you want)
Optional: Add help text like “Schedule publish time (UTC)”.

Pro tip: Make it optional so you can still publish instantly if you want.

Step 3: Choose Your Automation Approach

There are three main ways to automate publishing in Contentful. Here’s the real talk on each:

Option 1: Use a Third-Party Automation Tool (Easiest)

If you don’t want to write code, tools like Zapier, Make (formerly Integromat), or n8n can trigger Contentful API calls based on time.

How it works:

Schedule a “zap” or scenario to run every 5-15 minutes.
It looks for entries with a publishAt in the past and not published.
It calls the Contentful API to publish them.

Pros:

No need to host your own scripts.
Decent UI for non-developers.
Easy to tweak.

Cons:

Can get pricey with lots of entries.
Limited flexibility for complex workflows.

Quick setup with Zapier:

Create a new Zap.
Use the “Schedule” trigger (run every X minutes).
Add a Contentful “Find Entries” action, filter where publishAt <= now and published = false.
For each entry, use Contentful’s “Publish Entry” action.

Option 2: Roll Your Own Script (Most Flexible)

If you want full control and aren’t afraid of Node.js, you can write a small script and run it on a schedule (using cron, GitHub Actions, or a cloud function).

How it works:

Script runs every X minutes.
Queries Contentful for entries ready to publish.
Calls the Contentful Management API to publish them.

Pros:

Total flexibility—handle edge cases, notifications, etc.
No third-party costs.

Cons:

You have to host and maintain it.
More moving parts to break.

Example outline (Node.js): js // Pseudocode - see Contentful docs for real code const contentful = require('contentful-management'); const client = contentful.createClient({ accessToken: 'your-token' }); const now = new Date();

const entries = await client.getEntries({ content_type: 'blogPost', 'fields.publishAt[lte]': now.toISOString(), 'sys.publishedAt[exists]': false });

for (const entry of entries.items) { await entry.publish(); }

Don’t forget to set up environment variables and error handling.

Option 3: Use Contentful’s Scheduled Actions (Enterprise Only)

If your company is on the Contentful Enterprise plan, there’s a feature called Scheduled Actions that does all this natively.

How it works:

Pick a time in the web app when you want to publish or unpublish content.
Contentful handles the rest.

Pros:

No code. Built-in UI.
Official support.

Cons:

Only for Enterprise customers (read: $$$).
Not available to most small teams.

Bottom line: Most folks reading this are better off with Option 1 or 2.

Step 4: Set Up Your Automation

Let’s walk through both the third-party and DIY routes.

If You’re Using Zapier or Make:

Create an account if you don’t have one.
Connect Contentful using your API keys.
Set up a scheduled trigger: Run every 10-15 minutes.
Add a filter/search step: Only entries where publishAt is in the past and not published.
Publish the entry: Use the Contentful action to publish.
Test with a draft entry: Set publishAt to a couple minutes from now, save as draft, and wait.

Watch out for: - API rate limits: Don’t set your schedule too aggressively. - Time zones: Store and compare times in UTC to avoid surprises.

If You’re Writing Your Own Script:

Get Contentful Management API credentials: You’ll need a Management API token, not just the Delivery API.
Write your script: Use the Contentful SDK or plain HTTP requests.
Schedule your script: Use cron, a serverless function, or CI/CD (like GitHub Actions).
Handle edge cases:
What if the publish fails?
Should you send alerts if it breaks?
Test, then deploy.

Pro tip: Keep your automation simple at first. Add logging so you can track what’s being published.

Step 5: Train Your Team (or Yourself)

This part gets skipped, but it’s crucial. Make sure everyone knows:

How to set the publishAt field (and in what time zone).
That entries won’t magically publish unless the field is filled and the automation is running.
Who to ask if something doesn’t go live.

Create a quick cheat sheet or Loom video to save future headaches.

Step 6: Monitor and Maintain

Automation breaks all the time—APIs change, tokens expire, or “someone” (it’s always someone) turns off a workflow by accident.

Set up email or Slack alerts for failures.
Check logs every so often.
Update API tokens before they expire.

Ignore: Over-engineering with fancy dashboards unless you’re publishing 100s of entries a day.

What About Unpublishing or Expiring Content?

You can use almost the exact same approach: Add an unpublishAt field and tweak your automation to unpublish entries at the right time. But be careful—unpublishing removes content from your live site, which can break links or layouts if you’re not careful.

A Few Tips (from Someone Who’s Fumbled This)

Test with throwaway content first. You don’t want to learn on your production blog.
Keep your scheduling window tight. If your script runs every 15 minutes, content could go live up to 15 minutes late. Most people won’t care, but if you need to hit an exact minute, shorten the interval.
Document your setup. Future you (and your teammates) will thank you.
Don’t overcomplicate. Start simple—add features as you actually need them.

Wrapping Up

Automating content scheduling in Contentful is totally doable, but it’s not plug-and-play. Don’t get lost in fancy workflows or try to automate everything right away. Start with the basics: add a publishAt field, pick a simple automation path, and make sure everyone knows how it works. Iterate from there. The best automation is the one you barely notice because it just works.