Claude Cowork + CMS Integration: Publishing Workflows for WordPress, Webflow & More

Most content teams still publish by hand. A writer finishes an article, then a coordinator manually enters metadata, sets categories, uploads images, configures SEO fields, schedules publication, and updates internal links—all in the CMS. This repetitive work eats 25–40 minutes per article. It breaks focus. It kills momentum. And it scales badly.

Claude Cowork solves this with direct CMS connectors. Instead of publishing articles manually, your team drafts content in Cowork, and Cowork pushes the finished article directly to your CMS—with metadata, SEO fields, featured images, canonical URLs, and publishing status all pre-configured. This guide covers how to set it up and what you can automate across every major CMS platform.

This is part of our complete series on Claude Cowork for content writers. If you're new to Cowork, start there.

How Cowork Connects to Your CMS

Claude Cowork uses MCP (Model Context Protocol) servers to connect to external systems. Think of an MCP server as a bridge between Cowork and your CMS. Cowork can read from your CMS (fetch style guides, existing articles, SEO patterns) and write to it (publish articles, create new posts, update metadata).

Here's what flows across that bridge:

• Article content — title, body text, excerpts
• Metadata — publication date, author, status (draft, published, scheduled)
• SEO fields — meta descriptions, keywords, canonical URLs, og:title/og:description
• Organization — categories, tags, taxonomies, post type
• Media — featured image, image alt text, image URLs
• Advanced fields — custom fields, relations to other posts, internal links

To set up the bridge, you give Cowork an API key or OAuth token for your CMS (the connector handles the authentication securely). Then you define which fields in your CMS map to which outputs from Claude. For example: "When Claude generates a JSON block with author_name, publish_date, and canonical_url, send that to the WordPress post's author field, publish_date field, and custom field named canonical_url."

Permissions matter here. Your CMS API token needs write access to the specific fields and post types you want to publish. Most CMS platforms let you create restricted API keys that only modify posts in a specific category or only set certain fields—use those restrictions. Never give Cowork's connector full CMS access.

WordPress + Cowork: Full Setup Guide

WordPress is the most common CMS platform, and it has the most mature Cowork integration. Here's how to wire it up.

Step 1: Generate a WordPress API Token

WordPress REST API uses Application Passwords (in WordPress 5.6+) or third-party OAuth plugins like WP OAuth. For Cowork, we recommend Application Passwords because they're built in and lightweight.

In your WordPress admin:

1. Go to Users > Your Profile (or the user account that Cowork will use)
2. Scroll to Application Passwords
3. Enter a name like Cowork CMS Integration
4. Click Create Application Password
5. Copy the generated password (you'll only see it once)

Paste that password into your Cowork connector configuration, along with your WordPress URL and the user login. Cowork will now be able to create, edit, and publish posts as that user.

Step 2: Map Cowork Outputs to WordPress Fields

Next, tell Cowork which fields in WordPress you want populated. A basic mapping looks like this:

WordPress uses custom fields (ACF, CMB2, or native meta fields) for SEO data. If you use Yoast SEO, Cowork can write directly to Yoast's REST endpoints for meta descriptions and canonical URLs. If you use ACF, create ACF fields for meta data and map them in Cowork.

Step 3: Test the Integration

Before automating an entire publishing workflow, test with a single article. Create a short Cowork session that drafts a blog post, then push it to WordPress as a draft. Check WordPress—does the post appear with correct title, content, excerpt, and metadata? If yes, the integration is working. If metadata is missing, adjust your field mappings and retry.

Webflow + Cowork

Webflow is a visual-first CMS with a powerful REST API. Unlike WordPress, Webflow doesn't have a traditional post editor—instead, it stores content in collections (which are like database tables for your website).

For blog articles in Webflow, you typically have a "Blog Post" collection with fields like Title, Body, Published Date, Author, Featured Image, Meta Description, and Slug. Cowork connects to Webflow's Collections API and can create new items (articles) in your Blog Post collection.

To set up: get a Webflow API token (in Webflow Settings > Integrations > API), then configure the Cowork connector with your site ID and collection ID. Map Claude's outputs to Webflow field names. When Cowork finishes an article, it creates a new collection item with all the fields populated. You can set it to auto-publish or leave items as drafts for review.

One limitation: Webflow collections don't support scheduled publishing natively. If you need to schedule an article for a future date, you'll either publish it as a draft (and publish manually later) or use Webflow's automation features (zapier integration, webhooks) to publish on a schedule.

HubSpot CMS + Cowork

HubSpot CMS is tightly integrated with HubSpot's marketing automation and CRM. If your team uses HubSpot for email, lead scoring, and campaigns, publishing blog articles through the HubSpot CMS connector in Cowork makes sense—articles can be automatically associated with existing email campaigns or lead nurture workflows.

HubSpot's API supports blog posts, landing pages, and site pages. The Cowork connector can:

• Create blog post items with title, content, author, featured image, and publish date
• Assign articles to blog topics (HubSpot's taxonomy)
• Configure SEO settings (meta description, slug, preview HTML)
• Associate articles with email campaigns or lead nurture programs
• Set publishing status (draft or published)

Setup is similar to WordPress: generate a HubSpot API key (in Settings > Integrations > Private Apps), configure the Cowork connector, and map fields. HubSpot's API is well-documented and reliable, so integration is usually straightforward.

Contentful + Cowork

Contentful is a headless CMS—it stores content in a structured format (JSON) and has no built-in website. Instead, your website is built separately (in Next.js, Gatsby, or another static site generator) and pulls content from Contentful via API.

This architecture is powerful for multi-channel publishing. One article stored in Contentful can be published as a blog post, as an email, as a social media asset, and as a PDF—all from the same source. Cowork fits naturally into this workflow.

To set up Contentful + Cowork:

1. Create a Contentful space and define a Blog Post content model (fields: title, body, excerpt, featured_image, meta_description, canonical_url, etc.)
2. Generate a Contentful API token (in Settings > API Keys > Content Management API)
3. Configure the Cowork connector with your space ID and API token
4. Map Claude's outputs to your content model fields
5. When Cowork finishes an article, it creates a new Contentful entry with all fields populated
6. Publish the entry manually, or configure Contentful webhooks to auto-publish on a schedule

Contentful's structured approach also means Cowork can enforce field constraints—if your Blog Post model requires a meta_description under 160 characters, the connector can validate Claude's output and reject entries that don't meet the spec.

The Cowork Zero-Touch Publishing Workflow

Here's how a complete publishing workflow works end-to-end. We call it the Zero-Touch Publishing Workflow because the article never touches the CMS admin interface.

Step 1: Brief — A product manager creates a brief in Slack or Cowork: "Write a 1,500-word article about Claude Cowork CMS integration. Target audience: content teams. Primary keyword: Claude Cowork CMS integration. Tone: direct, no fluff."

Step 2: Cowork Research & Drafting — A writer starts a Cowork session, pastes the brief, and asks Claude to research the topic (Cowork can fetch existing blog posts and guides), draft the article, and generate SEO metadata (title tag, meta description, slug, featured image alt text).

Step 3: QA & Refinement — The writer reviews Claude's draft in Cowork, asks for edits (tone adjustments, fact-checks, additional sections), and waits for Claude to refine. This all happens in Cowork—no copying to a Word doc or Google Doc.

Step 4: CMS Publishing — Once the draft is approved, the writer clicks "Publish to CMS" (or types a command) in Cowork. Cowork's CMS connector formats the article (title, body, featured image, SEO fields), and pushes it to WordPress/Webflow/HubSpot/Contentful as a draft or published post. The entire publish operation takes less than 2 minutes.

Step 5: Verification — The article appears in the CMS. The editor opens the CMS and does a final visual check (does the article render correctly? Is the featured image the right size? Is the meta description showing up?). If any tweaks are needed, they're usually quick (crop an image, reword a headline). Most of the time, the article is already publication-ready.

Compare this to the traditional workflow: research (browser + doc), drafting (doc or CMS editor), copy-paste to CMS, manually set categories/tags, upload featured image, write meta description, set canonical URL, schedule publication. That's 5–6 context switches and 25–40 minutes of work. Zero-Touch cuts it to one 2-minute action in Cowork.

Prompt Templates for CMS Publishing

Here are three Cowork prompts you can adapt for your publishing workflow.

Prompt 1: Complete Article + CMS Package

You are an expert content strategist writing for [PUBLICATION]. Write a 1,500-word article about [TOPIC]. Target keyword: [KEYWORD]. Audience: [AUDIENCE]. Tone: [TONE].

After the article, generate a JSON block with this structure (do NOT include markdown backticks—just the JSON):

{
  "title": "[Article title, under 60 characters]",
  "excerpt": "[2-sentence excerpt, under 160 characters]",
  "meta_description": "[SEO meta description, 150–160 characters]",
  "slug": "[URL slug, lowercase, hyphens]",
  "canonical_url": "https://claudeimplementation.com/[slug]",
  "featured_image_alt_text": "[Descriptive alt text for featured image]",
  "primary_category": "[Category name]",
  "tags": ["tag1", "tag2", "tag3"],
  "internal_links": [
    {"anchor_text": "[link text]", "url": "[internal URL]"},
    {"anchor_text": "[link text]", "url": "[internal URL]"}
  ]
}

Write the article first, then the JSON block.

Prompt 2: Metadata Optimization for Published Articles

I have a published blog article. Review it and generate optimized CMS metadata.

Article Title: [TITLE]
Article Body: [PASTE ARTICLE TEXT]
Target Keyword: [KEYWORD]

Generate a JSON block with optimized values:

{
  "title": "[Improved title, under 60 chars, includes keyword]",
  "meta_description": "[Optimized description, 150–160 chars, includes keyword and CTA]",
  "slug": "[URL slug derived from title]",
  "featured_image_alt_text": "[Descriptive alt text]"
}

Ensure meta_description includes a subtle call-to-action (e.g., "Learn how..." or "Discover...").

Prompt 3: Internal Link Strategy

I'm publishing an article on [TOPIC]. Our existing blog posts cover these topics: [LIST EXISTING ARTICLES WITH URLS].

Identify the best places to insert internal links in this article:

[PASTE ARTICLE TEXT]

For each internal link opportunity, provide:
1. Where in the article to add the link (quote the surrounding text)
2. The anchor text
3. Which existing article to link to
4. Why that link adds value

Format as JSON:

{
  "internal_links": [
    {
      "context": "[surrounding text]",
      "anchor_text": "[link text]",
      "target_url": "[URL]",
      "rationale": "[why this link helps]"
    }
  ]
}

What Cowork Cannot Yet Do in CMS

Cowork's CMS integration is powerful, but it has limits. Here's what you still need to do manually.

• Large image uploads — Cowork can reference image URLs and set alt text, but it can't upload new images from your computer. You'll still upload featured images manually, or use a separate image management service (Cloudinary, imgix) and pass Cowork image URLs.
• A/B testing setup — If you use HubSpot's built-in A/B test tools, Cowork can't configure test variants. You'll set up the test manually in HubSpot after publishing.
• Campaign associations — HubSpot lets you associate articles with marketing campaigns. Cowork can set a campaign ID in a field, but can't query your CMS to find the right campaign. You'll need to specify the campaign ID in the prompt or set it manually.
• Structured data / schema markup beyond basic Article schema — Cowork can generate SEO metadata, but complex schema.org markup (FAQPage, BreadcrumbList, etc.) usually needs manual review.
• Custom redirects — If an old URL needs to redirect to the new article, set up the redirect manually in your CMS (WordPress Redirection plugin, Webflow native redirects, etc.).
• Media library optimization — CMS media libraries often have image compression and thumbnail generation. Cowork doesn't control those settings—the CMS handles them automatically.

None of these are blocking issues. They're edge cases that affect maybe 10% of articles. For the other 90%, Cowork eliminates all the manual work.

Before vs. After: Manual CMS Upload vs. Cowork Publishing

Here's a real-world comparison for a 1,500-word blog article.

The savings scale across your content calendar. If a team publishes 20 articles per month, Cowork saves 800 minutes (13+ hours) per month in mechanical publishing work. That's time your team can spend on strategy, audience research, and original reporting instead.

Related Articles

This article is part of our Claude Cowork series for content writers. Read the rest:

• Claude Cowork for Content Writers (Pillar) — Overview of how Cowork changes content workflows
• Claude Cowork Content Writer Tips & Workflows — Practical tips for maximizing Cowork in your daily work
• Claude Cowork for Content Research — How to use Cowork to research and validate claims
• Claude Cowork for Content Editing & QA — Editing workflows and quality checks with Cowork
• How Freelance and In-House Content Writers Use Claude Cowork to Scale Output — ROI and scaling strategies

Also explore our service pages:

• Claude Cowork Deployment — Full setup and deployment guide
• Claude Cowork Product Guide — Feature breakdown and capabilities
• MCP Protocol Guide — Deep dive into Model Context Protocol and custom connectors

FAQ