Notion Connector

Overview

Notion is a popular workspace tool where teams manage wikis, databases, and project trackers. The Trellis Notion connector lets you use your existing Notion databases as the content source for your Webflow CMS.

Whether you are publishing blog posts, managing a team directory, or maintaining a product catalog, Trellis handles the translation between Notion's flexible database model and Webflow's structured CMS collections.

How it works

1. Connect — authenticate with Notion via OAuth. Trellis requests access to the pages and databases you choose to share.
2. Select a database — choose which Notion database to sync. Each database maps to one Webflow CMS collection.
3. Map properties — match Notion database properties to CMS collection fields. Trellis auto-suggests mappings based on property names and types.
4. Sync — Trellis pushes structured property data from Notion to your CMS. Changes are detected and synced on a schedule or via webhook triggers.

Property type mapping

Notion and Webflow use different terminology for field types. Here is how they map:

Notion Property	Webflow CMS Field	Notes
Title	Plain text	The primary name field
Rich text	Rich text	Inline formatting preserved
Select	Option	Single choice from predefined values
Multi-select	Multi-option	Multiple choices
Date	Date	Start date used; end date ignored
Checkbox	Switch (boolean)	Direct mapping
URL	Link	Direct mapping
Files & media	Image	First file used for single image fields
Relation	Reference	Requires both databases to be synced
Rollup	Varies	Synced as the computed result (see below)
Formula	Varies	Synced as the computed result (see below)
Number	Number	Direct mapping
Email	Email	Direct mapping
Phone number	Phone	Direct mapping
Created time	Date	Auto-set by Notion
Last edited time	Date	Auto-set by Notion
Created by	Plain text	Displays user name
Last edited by	Plain text	Displays user name
Status	Option	Maps to a select-style field

Properties vs. page content

Notion pages have two layers of data:

• Properties — structured data in the database header (title, status, tags, dates). These are the columns you see in table view.
• Blocks — the actual page content below the header (paragraphs, headings, images, callouts, toggles).

Trellis syncs properties only, not inline page content. This is by design — properties are structured and map cleanly to CMS fields, while block content is freeform and varies widely between pages.

If you need page body content in your CMS, use the rich text property in Notion to store a summary or excerpt, and sync that field.

Image handling

Notion file and media URLs are temporary — they expire after approximately 1 hour. If you map a Notion file property directly to a Webflow image field, the URL will break once it expires.

Trellis solves this automatically:

1. During sync, Trellis downloads every image from Notion before the URL expires.
2. The image is uploaded to Webflow's Asset Manager, which generates a permanent CDN-backed URL.
3. Trellis stores the mapping between the Notion file and the Webflow asset ID so that subsequent syncs can skip unchanged images.

This means your Webflow site always has working image URLs, even if you never touch the sync again. On updates, Trellis compares file hashes — if the image has not changed, it reuses the existing Webflow asset instead of re-uploading.

For more detail on how Trellis handles images across all connectors, see Image Handling.

Rate limits and sync performance

The Notion API enforces a rate limit of 3 requests per second. This is significantly lower than most other APIs, and it affects how quickly Trellis can sync large databases.

Here is what that looks like in practice:

• A 100-item database with nested blocks or multiple relation lookups could require 200+ individual API calls.
• A 1,000-item database on its initial sync may take several minutes to complete.
• Subsequent syncs are faster because Trellis only fetches items that have changed.

To work within these constraints, Trellis uses several strategies:

• Request batching — multiple property reads are combined into single API calls where the Notion API supports it.
• Exponential backoff with jitter — when rate-limited, Trellis retries with increasing delays plus randomized jitter to avoid thundering-herd problems.
• Snapshot caching — Trellis caches Notion data snapshots locally so that if a sync is interrupted and retried, it does not re-fetch pages that were already retrieved.
• Delta detection — after the initial sync, Trellis queries Notion for only the pages modified since the last sync timestamp, dramatically reducing the number of API calls.

Webhooks and polling

Notion added webhook support in 2024-2025, but with an important limitation: webhook events return only page IDs and timestamps, not the actual page content. Every webhook notification still requires a follow-up API call to retrieve the data.

Trellis uses a hybrid approach to keep your content in sync:

• Webhooks for real-time triggers — when available and configured, Notion webhooks notify Trellis immediately when a page is created, updated, or deleted. Trellis then fetches the changed data via the API.
• Scheduled polling as a safety net — webhooks can be missed (network issues, Notion outages, configuration changes). Trellis runs periodic polls to catch anything the webhook might have missed.
• Event reconciliation — if both the webhook and the poll detect the same change, Trellis deduplicates them so items are never synced twice in the same cycle.

This hybrid model gives you near-real-time updates with the reliability of polling as a fallback.

Draft and publish workflow

Notion has no native concept of "Draft" vs. "Published." Every page in a database is simply a page — there is no built-in mechanism to control which items are live on your website.

Recommended setup: Add a Status select property to your Notion database with values like:

• Draft — work in progress, not yet ready
• In Review — content is complete, awaiting approval
• Published — approved and ready to go live

In Trellis, configure your sync to filter by Status = "Published". Only items with that status value will be pushed to your Webflow CMS. Items in Draft or In Review are ignored until their status changes.

When someone changes an item's Status from "In Review" to "Published," Trellis picks up the change on the next sync cycle (via webhook or scheduled poll) and pushes the item live. Similarly, changing a published item back to "Draft" will remove it from Webflow on the next sync.

This gives your team a lightweight editorial workflow without leaving Notion.

Computed fields with Notion data

Trellis computed fields let you transform Notion property values during sync — creating new CMS field values that do not exist as standalone properties in your database.

Here are common patterns for Notion data:

• Auto-generate URL slugs from titles: {Title} becomes slugify({Title}) — converts "My Blog Post Title" to "my-blog-post-title"
• Format dates for display: {Publish Date} becomes formatDate({Publish Date}, "MMMM D, YYYY") — converts a raw date to "March 15, 2026"
• Concatenate fields: {Author Name} + ", " + {Author Role} — produces "Jane Smith, Senior Editor"
• Conditional values: IF({Featured}, "Featured", "") — outputs "Featured" badge text when the checkbox is checked, empty string otherwise
• Replace Notion formulas: if your Notion database has a formula property that computes a value Webflow needs (e.g., a reading time estimate or a formatted price), you can replicate that logic as a Trellis computed field. This keeps the transformation in the sync pipeline rather than depending on Notion's formula engine.

See Computed Fields for the full expression reference.

Formulas and rollups

Notion formulas can nest up to 15 layers deep and perform complex calculations across properties. Rollups aggregate data from related databases (1 level deep, max 25 relations).

Neither of these has a direct equivalent in Webflow CMS. Webflow fields are static values — there is no formula engine.

Trellis handles this by reading the computed result from Notion and syncing it as a plain value. A formula that outputs a number syncs as a number field. A formula that outputs text syncs as a plain text field. The value in Webflow reflects whatever Notion last computed.

Important caveat: because the synced value is a snapshot, it will not update in Webflow until the next sync runs. If your formula depends on a frequently changing input (like "days until event"), the Webflow value may be stale between syncs.

For formulas that need to remain dynamic in Webflow — or for cases where you want to modify the formula logic without changing your Notion database — use Trellis computed fields to replicate the calculation during sync. This keeps the logic in the sync pipeline and updates every time Trellis runs.

Relations

Notion relations connect pages across databases. Trellis supports syncing these as Webflow Reference and Multi-Reference fields, but there are a few requirements and limitations to be aware of.

Requirements:

• Both the source database and the related database must be connected in Trellis. You cannot sync a relation if only one side is set up.
• The related database must be synced before or at the same time as the database that references it, so that Webflow has the referenced items available.

Mapping behavior:

• One-to-many relations (e.g., each Blog Post has one Author) map to a Webflow Reference field.
• Many-to-many relations (e.g., Blog Posts have multiple Tags, and Tags appear on multiple Posts) map to a Webflow Multi-Reference field.
• Self-referencing relations (e.g., a "Related Posts" relation on a Blog Posts database that points back to itself) are supported. Trellis handles the circular reference by syncing items first, then updating the relation pointers in a second pass.

Webflow limits: Webflow allows a maximum of 5 Multi-Reference fields per collection. If your Notion database has more than 5 many-to-many relations, you will need to choose which ones to sync. Trellis will warn you if you exceed this limit during field mapping.

Common use cases

Notion databases map naturally to many types of Webflow CMS content:

• Blog posts (highest demand) — Title, Author (relation), Category (select), Status (select), Featured Image (file), Tags (multi-select), Publish Date (date), Excerpt (rich text)
• Team directories — Name (title), Role (select), Bio (rich text), Photo (file), Department (select), Email (email), LinkedIn (URL)
• Product catalogs — Product Name (title), Description (rich text), Price (number), Category (select), Images (files & media), SKU (rich text)
• Event listings — Event Name (title), Date (date), Location (rich text), Description (rich text), Registration URL (URL), Featured (checkbox)
• Knowledge bases — Article Title (title), Category (select), Body Excerpt (rich text), Last Updated (last edited time), Author (relation)

Each of these patterns works out of the box with Trellis auto-mapping. Select a database, confirm the suggested field mappings, and sync.

Tips

1. Share databases with Trellis — during OAuth, Notion asks which pages/databases to share. Make sure you include the databases you want to sync.
2. Use consistent select values — Notion select options must match CMS option values exactly. If your Notion select has "Blog Post" but Webflow expects "blog-post," use a computed field to transform the value.
3. Relations require both databases — to sync reference fields, both the source and related databases must be connected.
4. Formulas and rollups are read-only — Trellis can read formula and rollup results, but they are computed by Notion, not editable. See the Formulas and Rollups section above for details.
5. Watch your rate limits — if you are syncing multiple large databases simultaneously, syncs may queue behind each other due to Notion's 3 req/s limit. Stagger initial syncs for the fastest results.
6. Use Status for publishing control — add a Status property and filter syncs to "Published" items only. This is the simplest way to prevent draft content from going live.

Learn more

• Notion API documentation
• Content Source Strategy — choosing the right source platform for your content.
• Image Handling — how Trellis manages images across all connectors.
• Computed Fields — expression reference for transforming data during sync.