CRM Overview

The CRM module lets you define custom entity types, fields, pipelines, and stages — then store structured data entries linked to any record in the system. Think of it as both a customer relations management tool and a general-purpose data platform (like Webflow CMS Collections). You can create traditional pipeline-based entities (deals, contacts) or standalone data collections (properties, inventory, cities).

How entries attach to records

Each CRM entry is linked to a record in your funnel or store through two values:

Field	Description
`reference_type`	The type of record (e.g. `customer`, `order`, `lead`)
`reference_id`	The ID of that record

This pattern lets you attach structured data to customers, orders, or custom reference types you define.

Concepts

Entries vs. Fields: An entry is a single record or document stored in the CRM (like a row in a database, representing e.g. a specific check-in for a customer). A field is a specific piece of data that lives inside an entry (like a column, e.g. “current_weight” or “deal_value”).

Entity Modes

Entities operate in one of two modes:

Mode	Description
CRM (default)	Traditional pipeline-based entity with stages, suitable for deals, leads, contacts
Data	Standalone data collection without pipelines — ideal for storing structured records like properties, inventory items, cities, products

When creating an entity, choose “Data Collection” to skip pipelines entirely. Data-mode entities focus purely on fields and entries.

Entities

An entity defines a type of CRM record (e.g. “Deals”, “Contacts”, “Properties”). Each entity has:

A name and slug (machine-readable identifier)
An entity mode (crm or data)
Fields that define the data structure
Pipelines with stages for workflow tracking (CRM mode only)

Fields

Fields define what data can be stored on entries. Each field has:

Property	Description
`label`	Human-readable label
`key`	Machine-readable key (used in API and templates)
`type`	See supported types below
`ui_editable`	Whether this field can be edited in the admin UI (default `true`)
`reporting_config`	Optional analytics metadata for CRM reports

Supported field types

Type	Renders as	Notes
`text`	Text input	Default type
`textarea`	Multi-line text
`rich_text`, `wysiwyg`	Rich text	Formatted content stored as HTML
`email`	Email input	Rendered as mailto link
`phone`	Phone input	Rendered as tel link
`url`	URL input	Rendered as clickable link
`number`	Numeric input	Stored as double
`date`	Date picker	ISO 8601 string
`datetime`	Date+time picker	ISO 8601 string
`boolean`	Toggle switch	true/false
`select`	Dropdown	Requires `options` array
`multiselect`	Multi-select tags	Requires `options` array
`color`	Color picker	Hex color code
`image`	Image URL / uploader	Renders as thumbnail
`file`	File URL / uploader	Renders as download link
`json`	JSON editor	Renders as collapsible tree
`reference`	Entity reference	Links to single entry in another entity
`multi_reference`	Multi-reference	Links to multiple entries in another entity

The type in CRM settings controls how the field appears and behaves in the admin UI. It does not change what you pass from code: setCrmField always sends a JavaScript value — a string, number, boolean, or a JSON object. For fields configured as date in the CRM, pass a date-time string from scripts, typically ISO 8601 (e.g. new Date().toISOString() or '2026-03-15').

UI-editable fields

Set ui_editable: false on fields that should only be updated programmatically (via backend scripts). These fields display with a lock icon in the admin UI and cannot be inline-edited. Use reporting_config to mark fields as reportable and suggest how the Reports tab should aggregate and chart them. Supported values include reportable, aggregation_type (numeric, categorical, date, boolean), baseline (min/max), bucket_size, and preferred_chart (kpi, histogram, pie, bar, line).

Relations

Relations link entries across entities. A field of type reference or multi_reference creates a relation between the current entity and a target entity. Relations are stored in Elasticsearch alongside the entry data.

Configuring reference fields

When creating a reference field, specify:

Target entity: Which entity the reference points to
Display field: Which field from the target entity to show as the label (defaults to title)

Working with relations programmatically

Use SetCrmRelation and RemoveCrmRelation to manage relations. These two are template-engine functions — they are not available in backend scripts:

SetCrmRelation({
  slug: 'properties',
  relationKey: 'city',
  targetEntryId: 'abc123'
});

RemoveCrmRelation({
  slug: 'properties',
  relationKey: 'city',
  targetEntryId: 'abc123'
});

Pipelines & Stages

Pipelines represent workflows (CRM mode only). Each pipeline contains ordered stages with optional colors and semantic statuses (e.g. won, lost, active). Entries move through stages as they progress.

Import entries from a file

Start a CRM object from a spreadsheet: open the object, go to Entries and click Import file. On an object with no fields yet, this is the main button and the page says so.

Choose a .csv or .xlsx file (up to 20,000 rows). The first row must hold the column names. For an Excel file, the first sheet is read. Old .xls and Numbers files need to be saved as .xlsx or .csv first.
Check the fields. Each column gets a row:
- Import as: New field (the default for a column with no matching field), Existing field (picked for you when the column name matches a field’s key or label), or Do not import.
- Field name and Field type for a new field. The name comes from the column header, and the type is guessed from the values: email, phone, link, number, date, date and time, yes / no, choice (a short list of repeated values, which become the field’s choices), several choices (cells that list items separated by ,, ; or |, such as tags, from a small set), long text, or text. Any value a choice field does not list yet is added to its choices during the import. Change either before importing.
- Entry title: the column each entry is named after (a name, company or email column is picked when there is one). With no title column, an entry takes its first text value.
- Pipeline and Stage, when the object has pipelines: every imported entry starts there.
Click Import rows. The new fields are created first, then the rows are added in batches with a progress bar. Empty rows are skipped, and a row that fails is listed with its row number.

The CRM Import entries page after choosing a CSV: one row per column with New field, the suggested field name and type, the Entry title picker and the Import rows button

Values are stored the way the field type expects: 1,234.50 and 12,5 become numbers, yes, true and 1 become yes, dates such as 01/31/2026 or Excel date cells become 2026-01-31, and a several-choices field splits on ;, , or |. When the object has an email or phone field, each imported row also creates or updates the matching contact, as an entry added by hand does. Imported rows do not start stage automations or send form webhooks. In the Entries list each field is its own column. Click Columns to choose which fields show and in what order; the choice is saved for each CRM object. The first time, the list shows the title, the first three fields, owner, stage and last update.

An import always adds new entries: importing the same file twice adds its rows twice. To change entries that already exist, edit them, or use the API.

Customer CRM Data

The most common pattern is linking CRM entries to customers. When a customer visits a page, their session supplies the customer context so CRM defaults attach to the right person (creating the customer record when needed).

Example: Weight Loss Tracker

Create a CRM entity called “Weight Tracker” with slug weight-tracker and fields like current_weight, goal_weight, last_checkin
Create a pipeline “Progress” with stages “Starting”, “In Progress”, “Goal Reached”
Store data via backend scripts or the template engine:

setCrmFields({
  slug: 'weight-tracker',
  fields: [
    { fieldKey: 'current_weight', value: 185 },
    { fieldKey: 'goal_weight', value: 165 },
    { fieldKey: 'last_checkin', value: '2026-03-15' }
  ]
});

slug identifies the CRM entity (board/type). referenceType / referenceId default to the current customer when omitted. For another record:

setCrmField({ slug: 'weight-tracker', referenceType: 'order', referenceId: '12345', fieldKey: 'status', value: 'shipped' })

. See Data Functions.

Read it back on any page:

var weight = getCrmField({ slug: 'weight-tracker', fieldKey: 'current_weight' });
var goal = getCrmField({ slug: 'weight-tracker', fieldKey: 'goal_weight' });
if (weight && goal && Number(weight) <= Number(goal)) {
  setVariable('show_congrats', true);
}

Viewing Customer CRM Data

Customer CRM entries are visible in the Customer Details page under the CRM tab. This shows all CRM entries linked to that customer across all entity types.

Functions

Write functions accept an optional async parameter (default false). When true, the write runs in the background for faster response times. Read functions are always synchronous.

The function names differ between the two runtimes, and calling the wrong one takes the page down.

Template engine ({{ }} / @if inside a page or component) — PascalCase: SetCrmFields({...})
Backend scripts (<script scope="backend"> and standalone scripts/*.js) — camelCase: setCrmFields({...})

An undefined function is not ignored — it aborts the render, and a live page starts returning 404. Three functions exist in templates only (CreateCrmEntry, SetCrmRelation, RemoveCrmRelation) and reassignCrmReference exists in backend scripts only; there is no createCrmEntry in a backend script. To create an entry from a backend script use addCrmFieldValue({...}), or setCrmFields({...}) to upsert.Test with a draft and open the preview URL before publishing.

The table below uses the backend-script (camelCase) spelling. For the template engine, capitalise the first letter.

Function	Description
`ensureCrmEntity({ slug, ... })`	Idempotently create an entity with fields (returns `{ id, slug, created, fields_added }`)
`CreateCrmEntry({ slug, title?, values?, ... })`	Template engine only. Create a new entry and return its ID. In a backend script use `addCrmFieldValue` / `setCrmFields` instead
`getCrmEntries({ slug, ... })`	Fetch all entries for one entity slug + reference
`getCrmField({ slug, fieldKey, ... })`	Get one field value (`slug` + `fieldKey` required)
`getCrmFields({ slug, fieldKeys, ... })`	Get multiple field values (`slug` + `fieldKeys` required)
`setCrmField({ slug, fieldKey, value, ... })`	Set one field value — upserts a single value per key
`setCrmFields({ slug, fields, ... })`	Set multiple field values in one read/write cycle
`addCrmFieldValue({ slug, fieldKey, value, ... })`	Append a new entry with a field value — enables multiple values per key
`getCrmFieldValues({ slug, fieldKey, ... })`	Get all values for a field key across entries (returns array)
`clearCrmEntries({ slug, ... })`	Delete all entries for an entity slug + reference
`SetCrmRelation({ slug, relationKey, targetEntryId, ... })`	Template engine only. Add a relation from entry to another entry
`RemoveCrmRelation({ slug, relationKey, targetEntryId, ... })`	Template engine only. Remove a specific relation
`reassignCrmReference({ slug, fromReferenceType, fromReferenceId, ... })`	Backend scripts only. Move entries from one visitor reference to another (e.g. anonymous → customer after login)
`moveCrmLead({ slug, pipelineId/pipelineSlug, stageId/stageSlug, ... })`	Move entry to a specific pipeline + stage
`moveCrmToStage({ slug, stageId/stageSlug, ... })`	Move entry to a stage (pipeline resolved from stage)
`moveCrmToPipeline({ slug, pipelineId/pipelineSlug, ... })`	Move entry to a pipeline (lands on first stage)
`moveCrmToEntity({ fromSlug, toSlug, fieldMap, ... })`	Copy mapped fields across entity types

slug is always required (the entity’s slug from CRM settings). Reference defaults: customer + session customer id.

Common options

Every CRM function accepts these optional properties:

Property	Type	Default	Description
`referenceType`	string	`'customer'`	Linked record type
`referenceId`	string	session `customer_id`	Linked record id

Write functions also accept:

Property	Type	Default	Description
`async`	boolean	`false`	When `true`, writes run in the background — faster but eventual consistency

Single-value fields

Use setCrmField / getCrmField for fields that hold one value per key (e.g. weight, goal, last check-in date):

setCrmField({ slug: 'weight-tracker', fieldKey: 'current_weight', value: 182 });
var weight = getCrmField({ slug: 'weight-tracker', fieldKey: 'current_weight' });

When you need to read multiple fields at once, use getCrmFields and pass an array of fieldKeys:

var fields = getCrmFields({ slug: 'weight-tracker', fieldKeys: ['current_weight', 'goal_weight'] });
var weight = fields.current_weight;
var goal = fields.goal_weight;

When writing multiple fields in one script, prefer setCrmFields so all values are merged in one read/write cycle:

setCrmFields({
  slug: 'weight-tracker',
  fields: [
    { fieldKey: 'current_weight', value: 182 },
    { fieldKey: 'goal_weight', value: 165 },
    { fieldKey: 'last_checkin', value: today }
  ]
});

If you need to keep separate setCrmField calls, pass force: true to skip the per-key scan and merge directly into the newest entry — much faster for sequential writes:

setCrmField({ slug: 'weight-tracker', fieldKey: 'current_weight', value: 182, force: true });
setCrmField({ slug: 'weight-tracker', fieldKey: 'goal_weight', value: 165, force: true });
setCrmField({ slug: 'weight-tracker', fieldKey: 'last_checkin', value: today, force: true });

Multi-value fields

Use addCrmFieldValue / getCrmFieldValues when a key can have multiple values over time (e.g. weigh-in history). Each addCrmFieldValue call creates a separate CRM entry:

addCrmFieldValue({
  slug: 'weight-tracker',
  fieldKey: 'weighin_history',
  value: { date: '2026-03-31', weight: 182, notes: 'post-workout' }
});

var history = getCrmFieldValues({ slug: 'weight-tracker', fieldKey: 'weighin_history', limit: 10 });
// Returns an array of values, newest first

Clearing entries

Use clearCrmEntries to delete all entries for an entity + reference:

var result = clearCrmEntries({ slug: 'weight-tracker' });
// { ok: true, deleted: 3 }

Pipeline and stage movement

Use moveCrmLead to move a CRM entry to a specific pipeline and stage by id or slug:

// By slug (recommended — works across environments)
moveCrmLead({ slug: 'deals', pipelineSlug: 'sales', stageSlug: 'qualified' });

// By id
moveCrmLead({ slug: 'deals', pipelineId: 3, stageId: 12 });

Returns { ok, moved, totalMatched, pipeline_id, stage_id }. moved is the number of entries updated (1 unless allEntries: true). Use moveCrmToStage when you only know the stage — the pipeline is resolved automatically:

moveCrmToStage({ slug: 'deals', stageSlug: 'won' });

Use moveCrmToPipeline to move an entry into a pipeline; it lands on the first stage:

moveCrmToPipeline({ slug: 'deals', pipelineSlug: 'onboarding' });

Use moveCrmToEntity to copy field values from one entity type to another (e.g. promoting a lead to a deal):

moveCrmToEntity({
  fromSlug: 'leads',
  toSlug: 'deals',
  fieldMap: { lead_score: 'initial_score', source: 'lead_source' },
  pipelineSlug: 'sales',
  stageSlug: 'new',
  removeFromOld: false  // set true to delete source entries after copy
});

Returns { ok, moved, removed_from_old }. Pass allEntries: true to any move function to update all matching entries instead of just the newest one.

Ensuring entities programmatically

Use EnsureCrmEntity at the top of a backend script to idempotently provision an entity. Re-runs never overwrite admin edits — only missing fields are added.

EnsureCrmEntity({
  slug: 'properties',
  name: 'Properties',
  singularName: 'Property',
  pluralName: 'Properties',
  entityMode: 'data',  // 'crm' (default) or 'data'
  icon: 'building',
  fields: [
    { key: 'address', label: 'Address', type: 'text' },
    { key: 'price', label: 'Price', type: 'number' },
    { key: 'bedrooms', label: 'Bedrooms', type: 'number' },
    { key: 'photo', label: 'Photo', type: 'image', ui_editable: false },
    { key: 'city', label: 'City', type: 'reference', options: { target_entity_id: 5 } },
    { key: 'status', label: 'Status', type: 'select', options: ['available', 'sold', 'pending'] },
    {
      key: 'listing_date',
      label: 'Listing Date',
      type: 'date',
      reportingConfig: { reportable: true, aggregationType: 'date' }
    }
  ]
});

Creating entries

Use CreateCrmEntry to create a new entry and get back its ID (useful for setting relations). This is a template-engine function — from a backend script use addCrmFieldValue({ slug, fieldKey, value }) or setCrmFields({ slug, fields }) instead, as there is no createCrmEntry there:

var result = CreateCrmEntry({
  slug: 'properties',
  title: '123 Main St',
  values: {
    address: '123 Main Street, Springfield',
    price: 450000,
    bedrooms: 3,
    status: 'available'
  }
});
// result = { ok: true, id: 'abc123' }

Managing relations

Use SetCrmRelation to link entries:

// Link a property to a city
SetCrmRelation({
  slug: 'properties',
  relationKey: 'city',
  targetEntryId: 'city-entry-id-here'
});

Use RemoveCrmRelation to unlink:

RemoveCrmRelation({
  slug: 'properties',
  relationKey: 'city',
  targetEntryId: 'city-entry-id-here'
});

Async writes

For non-critical writes where you don’t need immediate consistency, pass async: true so the write runs in the background:

setCrmField({ slug: 'weight-tracker', fieldKey: 'last_page_view', value: today, async: true });
setCrmFields({ slug: 'weight-tracker', fields: [{ fieldKey: 'current_weight', value: 182 }, { fieldKey: 'last_checkin', value: today }], async: true });
addCrmFieldValue({ slug: 'weight-tracker', fieldKey: 'page_views', value: { url: '/dashboard', ts: today }, async: true });
moveCrmLead({ slug: 'deals', pipelineSlug: 'sales', stageSlug: 'contacted', async: true });

See Data Functions for full parameter details and examples.

Get started

Build

Sell

Grow and track

Manage

Developers

How entries attach to records

Concepts

Entity Modes

Entities

Fields

Supported field types

UI-editable fields

Relations

Configuring reference fields

Working with relations programmatically

Pipelines & Stages

Import entries from a file

Customer CRM Data

Example: Weight Loss Tracker

Viewing Customer CRM Data

Functions

Common options

Single-value fields

Multi-value fields

Clearing entries

Pipeline and stage movement

Ensuring entities programmatically

Creating entries

Managing relations

Async writes

​How entries attach to records

​Concepts

​Entity Modes

​Entities

​Fields

​Supported field types

​UI-editable fields

​Relations

​Configuring reference fields

​Working with relations programmatically

​Pipelines & Stages

​Import entries from a file

​Customer CRM Data

​Example: Weight Loss Tracker

​Viewing Customer CRM Data

​Functions

​Common options

​Single-value fields

​Multi-value fields

​Clearing entries

​Pipeline and stage movement

​Ensuring entities programmatically

​Creating entries

​Managing relations

​Async writes

How entries attach to records

Concepts

Entity Modes

Entities

Fields

Supported field types

UI-editable fields

Relations

Configuring reference fields

Working with relations programmatically

Pipelines & Stages

Import entries from a file

Customer CRM Data

Example: Weight Loss Tracker

Viewing Customer CRM Data

Functions

Common options

Single-value fields

Multi-value fields

Clearing entries

Pipeline and stage movement

Ensuring entities programmatically

Creating entries

Managing relations

Async writes