Skip to main content

Overview

The Webflow connector integrates with Webflow’s CMS API to publish articles directly to your Webflow collections. It supports:
  • Publishing to any CMS collection
  • Flexible field mapping for custom collection structures
  • HTML content formatting optimized for Webflow
  • Category and tag synchronization
  • Scheduled publishing

Prerequisites

Before connecting, ensure you have:
  1. Webflow site with CMS enabled
  2. CMS Collection for blog posts/articles
  3. API token with CMS write permissions
  4. Site ID from your Webflow dashboard

Setup Guide

Step 1: Get Your Site ID

  1. Go to your Webflow dashboard
  2. Open your site’s settings
  3. Find the Site ID in the URL or settings panel

Step 2: Create an API Token

  1. Go to Webflow Dashboard → Account Settings → Integrations
  2. Or visit webflow.com/dashboard/account/integrations
  3. Click Generate API Token
  4. Select the sites you want to grant access to
  5. Enable CMS permissions (read and write)
  6. Copy the generated token
API tokens provide full access to your Webflow CMS. Store them securely and never share them publicly.

Step 3: Get Your Collection ID

  1. In Webflow Designer, go to CMS Collections
  2. Select your blog/articles collection
  3. The Collection ID is in the URL: collections/{collection-id}
Or use the API:
curl -H "Authorization: Bearer YOUR_TOKEN" \
  "https://api.webflow.com/v2/sites/YOUR_SITE_ID/collections"

Step 4: Configure Field Mapping

Map Skayle fields to your Webflow collection fields:
interface WebflowConnectorConfig {
  type: "webflow";
  siteId: string;         // Your Webflow site ID
  token: string;          // API token
  collectionId: string;   // Collection ID for articles

  fieldMapping: {
    title: string;        // Field slug for title
    slug: string;         // Field slug for slug
    excerpt: string;      // Field slug for excerpt
    content: string;      // Field slug for body (Rich Text)
    featuredImage?: string; // Field slug for main image
    publishAt?: string;   // Field slug for publish date
    status?: string;      // Field slug for status
  };

  taxonomyMapping: {
    category: string;     // Multi-reference field for categories
    tag: string;          // Multi-reference field for tags
    author: string;       // Reference field for author
  };
}

Step 5: Configure in Skayle

  1. Go to Settings → Connectors in Skayle
  2. Select Webflow as your connector type
  3. Enter your configuration:
FieldDescriptionExample
Site IDYour Webflow site IDabc123xyz
TokenAPI tokenwf_...
Collection IDBlog collection IDdef456
Title FieldField slug for titlename
Slug FieldField slug for slugslug
Content FieldField slug for bodypost-body
Excerpt FieldField slug for excerptpost-summary
  1. Click Test Connection to verify

Webflow Collection Setup

Here’s a recommended collection structure for blog posts:

Required Fields

Field NameField TypeSlugNotes
NamePlain TextnameArticle title
SlugPlain TextslugURL slug
Post BodyRich Textpost-bodyMain content
Post SummaryPlain Textpost-summaryExcerpt

Optional Fields

Field NameField TypeSlugNotes
Main ImageImagemain-imageFeatured image
Publish DateDatepublish-datePublication date
CategoriesMulti-ReferencecategoriesLink to Categories collection
TagsMulti-ReferencetagsLink to Tags collection
AuthorReferenceauthorLink to Authors collection

Content Formatting

Skayle converts BlockNote JSON to minified HTML optimized for Webflow’s Rich Text fields.

Why Minified HTML?

Webflow’s CMS editor interprets newlines between tags as line breaks, which can cause rendering issues (especially with lists). Skayle minifies HTML to prevent this:
<!-- Before minification -->
<ul>
  <li>Item 1</li>
  <li>Item 2</li>
</ul>

<!-- After minification (what Skayle sends) -->
<ul><li>Item 1</li><li>Item 2</li></ul>

Supported Elements

BlockNote TypeHTML Output
Paragraph<p>
Heading 1-6<h1> - <h6>
Bullet List<ul><li>
Numbered List<ol><li>
Blockquote<blockquote>
Code Block<pre><code>
Image<img>
Link<a>
Bold<strong>
Italic<em>
Webflow Rich Text fields have specific HTML requirements. Skayle automatically formats content to be compatible.

Taxonomy Mapping

Multi-Reference Fields

Webflow uses multi-reference fields for many-to-many relationships:
  1. Create separate collections for Categories and Tags
  2. Add multi-reference fields to your Posts collection
  3. Configure the field slugs in Skayle

Syncing Process

Fetches items from your taxonomy collections:
GET /collections/{categories-collection-id}/items
GET /collections/{tags-collection-id}/items
Creates Skayle taxonomies and stores mappings.

Image Handling

Webflow requires images to be hosted externally or uploaded to their CDN:

External URLs

For image fields, provide the full URL:
{
  "main-image": {
    "url": "https://example.com/image.jpg",
    "alt": "Image description"
  }
}

Webflow Assets

For better performance, consider uploading to Webflow’s asset manager first.
Webflow has strict image requirements. Ensure images are publicly accessible and use supported formats (JPG, PNG, WebP, GIF).

Publishing Workflow

Draft vs Published

Webflow items can be in draft or published state:
  1. Draft: Item exists but isn’t live on the site
  2. Published: Item is live and visible
Skayle creates items as drafts by default. To publish:
  • Use Webflow’s publish feature
  • Or configure auto-publish in your workflow

Staging vs Production

Webflow has staging and production environments:
  1. CMS changes go to staging first
  2. Publishing the site pushes changes to production
After Skayle publishes content, you may need to publish your Webflow site to make changes live.

Troubleshooting

Connection Issues

  • Verify your API token is correct
  • Check token hasn’t been revoked
  • Ensure token has CMS permissions
  • Verify Site ID is correct
  • Check Collection ID exists
  • Ensure collection is in the correct site
  • Webflow has API rate limits
  • Wait and retry
  • Consider batching requests

Publishing Issues

  • Check field slugs match exactly
  • Verify required fields are mapped
  • Ensure field types are compatible
  • Check HTML is properly formatted
  • Verify no unsupported tags
  • Test with simple content first
  • Ensure taxonomy collections exist
  • Run taxonomy sync first
  • Verify reference field configuration

API Rate Limits

Webflow enforces API rate limits:
PlanRequests/Minute
Starter60
CMS120
Business120
EnterpriseCustom
Skayle handles rate limiting automatically with exponential backoff.

Best Practices

  1. Test field mapping: Verify all fields work before bulk publishing
  2. Use staging: Test content in staging before publishing to production
  3. Sync taxonomies first: Always sync categories/tags before articles
  4. Monitor rate limits: Don’t publish too many articles at once
  5. Backup collections: Export your CMS data regularly

Next Steps