Twenty CRM Workflow Automation: The Complete Guide

Your CRM should run the follow-up, not just record it. Twenty ships with a built-in workflow engine, inbound and outbound webhooks, and a REST and GraphQL API generated from your own data model, so most sales and operations automation can live inside the CRM instead of a separate automation subscription. This guide walks through the full trigger and action catalog with its real limits, the workflow credit model with actual numbers, when to drop down to webhooks or the API, and what the whole thing costs compared with HubSpot for a 20 person team.

Everything below comes from Twenty's official documentation, pricing page, and GitHub repository, retrieved and cross-checked in November 2026. Where Twenty itself flags a limitation, you will see it flagged here.

What Twenty workflows can do: the trigger catalog

Every Twenty workflow starts with exactly one trigger. The official triggers documentation lists six types:

• Record is Created: fires when a new record appears in a selected object, including custom objects. Best for records created by CSV import, mailbox and calendar sync, or the API. Twenty explicitly warns against using it for manually created records: the UI auto-saves as you type, so the workflow fires before the user finishes filling in fields. Use the combined trigger instead.
• Record is Updated: fires on changes to an existing record. You can monitor specific fields, so the workflow only runs when, say, an opportunity stage changes rather than on every edit.
• Record is Updated or Created: the safe default for anything that might be entered by hand, because it catches both the initial creation and the field completions that follow.
• Record is Deleted: cleanup automations, audit pings, or syncing deletions to other systems.
• Manual: launched by a person from the Cmd+K command menu or a pinned button in the navbar. Three availability modes: Global (no record input), Single (runs once per selected record, with a soft limit of 100 runs per minute), and Bulk (runs once with the whole selection as input, which requires an Iterator action).
• On a Schedule: recurring runs in minutes, hours, or days, with custom cron expressions for anything more complicated. Scheduled workflows run in UTC, so convert your local time when setting daily schedules.

There is also a seventh option worth calling out separately: the external webhook trigger, covered in the webhooks section below.

One detail that experienced CRM admins will appreciate: workflows are not limited to People, Companies, and Opportunities. You can trigger on and act on Workspace Members, Calendar Events, email Messages, Tasks, Notes, and custom objects. That makes automations like "notify the account owner when a meeting is booked" or "process inbound emails matching a pattern" possible without leaving the platform.

The action catalog and its real limits

The actions documentation groups actions into record operations, communication, and integration. Here is what each one does, including the limits Twenty documents:

Record actions

• Search Records, Create Record, Update Record, Delete Record: standard CRUD on any object, with variables passed between steps. These are the cheapest actions to run in credit terms.

Communication actions

• Send Email: sends from a mailbox synced to your own Twenty account. Documented limits: one recipient per action, no HTML signatures yet, and you cannot send from a teammate's mailbox (that is on the roadmap).
• Draft Email: same configuration, but saves to the sender's Drafts folder. The right pattern for AI-generated or workflow-generated emails that a human should review before they go out.
• Create Calendar Event: creates an event on a connected calendar with attendees, optional conferencing link, and optional invitations.
• Form: opens a form for the person running the workflow and pipes the answers into later steps. Forms are for manual triggers only, and fields cannot be made mandatory.
• Send to Inbox: the approval pattern. Use this when a workflow should pause for a human decision.

Logic and integration actions

• Code: runs custom JavaScript, backed behind the scenes by a server-side TypeScript logic function. One catch worth knowing before you build: API keys for external services must be written directly in the function body. If several workflows need the same logic, define a reusable logic function through the Apps SDK instead of copy-pasting inline code into each step.
• HTTP Request: calls any external REST endpoint and returns the response for later steps.
• Iterator: loops over a list, required for Bulk manual triggers and for processing arrays from search steps.
• Delay: pauses the run. Almost free: 0.0001 credit per execution, and a five minute delay costs the same as a five day one.
• AI Agent: runs an AI step inside the workflow, with credit consumption that scales with the model and output length.

The honest summary: the catalog covers CRM-internal automation well. It is deliberately thinner on external app integrations than Zapier or Make, which is why the webhooks and API matter.

How workflow credits work, with real numbers

Twenty meters automation through workflow credits, documented on the workflow credits page. The model:

• Allocation: 5 credits per month on monthly billing, or 50 credits per year on annual billing. Credits come with the billing cycle, not the plan tier.
• Consumption: record operations (search, create, update, delete, forms) cost very little. Code actions and HTTP requests cost more. AI Agent actions cost the most, scaled by model and output length. Drafts cost nothing; only running workflows consume. A failed run still burns credits for the steps that completed.
• Top-ups: buy more in Settings then Billing whenever you need them. The conversion is simple: 1 credit equals $1 of usage, per the credits documentation, which also publishes per-action rates. A standard workflow step (search, create, or update a record) costs $0.0001, so one credit covers roughly 10,000 such steps.

A worked example. Take a typical lead follow-up sequence: an Update Record step, a Send Email, a three day Delay, a conditional Draft Email. The record update and emails sit in the very low consumption band, and the Delay costs 0.0001 credit. The whole run costs a small fraction of a credit. Twenty's own guidance is that most teams on standard automations will not exceed the included 5 monthly credits, and that additional credits are mainly needed for heavy Code actions and AI-powered workflows. If your automation strategy is "AI drafts a personalised email for every new lead," budget for credit packs and monitor Settings then Billing during the first month.

Worked example: a lead follow-up sequence, step by step

Here is a concrete build that uses the pieces above. Scenario: leads arrive from your website form through the API, and you want a fast first touch plus a human-reviewed nudge.

1. Trigger: Record is Created on the People object. Safe here because API-created records arrive with all fields populated, which is exactly the case Twenty recommends this trigger for.
2. Filter: continue only if the lead source field equals website. Skips partners, imports, and event lists.
3. Update Record: assign the lead owner based on territory and set the pipeline stage to contacted.
4. Send Email: a short welcome note from the owner's synced mailbox. Remember the limits: one recipient, plain formatting, no HTML signature.
5. Delay: three days. Cost: 0.0001 credit.
6. Search Records: check whether any email activity from the lead exists since the first touch.
7. Draft Email: if there is no reply, generate a follow-up with the AI Agent action and park it in the owner's Drafts folder for review rather than sending it blind.

Total credit cost per lead: a fraction of one credit for steps 2 through 6, plus whatever the AI Agent step consumes, which depends on the model you pick. At 300 new leads a month with a modest AI prompt, you will want to watch the Billing page, but the non-AI portion of the sequence is effectively free inside the included allocation.

Webhooks: events in and out of Twenty

Webhooks are the bridge between Twenty's internal engine and everything else.

Inbound: the external webhook trigger gives each workflow a unique URL that accepts GET or POST requests. For POST, you declare the expected body structure up front so the fields are available as variables downstream. One caveat straight from the docs: authentication on inbound webhook triggers is marked as coming soon. Until it ships, treat the URL as a secret and do not send sensitive payloads to it from systems you do not control.

Outbound: Twenty fires webhooks to external endpoints on record events. The webhooks documentation defines the payload: an event field naming what happened (for example person.created), a data field with the full record, and a UTC timestamp. Point those at n8n, a queue, or your own endpoint and you can drive invoicing, Slack alerts, or a data warehouse sync.

The REST and GraphQL API: built from your schema

Twenty has no static API reference, because there is no static API. Per the API documentation, every workspace gets REST and GraphQL endpoints generated from its own schema. Add a custom object called Invoice and it immediately has the same endpoints as Company or Person, using your field names rather than opaque IDs.

The practical details:

• Two APIs: the Core API (/rest/ and /graphql/) for record CRUD, filtering, and relations, and the Metadata API (/rest/metadata/) for managing objects, fields, and relations programmatically.
• Base URLs: https://api.twenty.com/ on Cloud, your own domain when self-hosted.
• Authentication: Bearer token API keys created in Settings then Developers then API. The key is shown once at creation, and keys can be scoped to a role to limit what they can touch.
• Batching: up to 60 records per request for create, update, or delete on both REST and GraphQL. GraphQL adds batch upsert with plural mutations like CreateCompanies.
• Field selection: pass a fields parameter to keep payloads small. On objects with more than 200 readable fields, Twenty returns a default subset unless you ask explicitly.

A minimal call looks like this:

curl "https://api.twenty.com/rest/people?fields=id,name,emails,company" \
  -H "Authorization: Bearer YOUR_API_KEY"

Your workspace also ships interactive, schema-specific API documentation with a live playground under Settings then Developers then API, so you can test real calls against real data before writing any code.

For teams running Claude, one more integration worth knowing: every Twenty Cloud workspace ships a native MCP server, so Claude can read and write CRM records in natural language over OAuth. Wiring that into a wider assistant is the kind of work our Claude implementation service covers.

Built-in workflows, n8n, or custom code: a decision checklist

Three layers, three jobs. Pick per automation, not per company.

• Use built-in workflows when the logic starts and ends in the CRM: stage changes, assignment, follow-up emails, task creation, approvals. Lower credit cost, no extra infrastructure, visible to admins in the UI.
• Add n8n (or Make) when the automation spans systems Twenty does not natively connect: accounting, telephony, marketing lists, SMS gateways. Twenty's outbound webhooks plus n8n's HTTP nodes cover most of this. For the wider platform trade-offs, see our n8n vs Zapier vs Make comparison.
• Use the API or a logic function when you need bulk operations (the 60 record batch ceiling is generous for sync jobs), custom object provisioning, or logic too complex for a visual builder. The Apps SDK lets you ship reusable logic functions that appear as native workflow actions.

If you are self-hosting Twenty as part of a wider open source stack, the same decision logic applies to Chatwoot, Listmonk, and the rest. Our managed open source stack service exists precisely for teams that want this layer run for them, and our business automation service covers the n8n and Make side.

What it costs: Twenty vs HubSpot for a 20 person team

This is where the automation question becomes a budget question. HubSpot gates full workflow automation behind Sales Hub Professional, while Twenty includes automations from its entry plan. List prices, annual billing:

• Twenty Pro: $9 per user per month, includes automations and unlimited custom objects. Twenty seats for a 20 person team: $180 per month, $2,160 per year. Source: Twenty pricing.
• Twenty Organization: $39 per user per month, adds custom roles with field and row-level permissions, SAML/OIDC SSO, and audit logs. For 20 people: $780 per month, $9,360 per year.
• HubSpot Sales Hub Professional: $90 per seat per month billed annually, or $100 if you pay monthly, the first tier with full workflow automation. For 20 seats on annual billing: $1,800 per month, $21,600 per year, plus a mandatory one-time onboarding fee of $1,500. Figures from HubSpot's own Sales Hub pricing guide; verify against HubSpot's pricing page before signing anything.
• HubSpot Sales Hub Enterprise: $150 per seat per month, required for custom objects, SAML SSO, and sandboxes. For 20 seats: $3,000 per month, $36,000 per year, plus a $3,500 one-time onboarding fee.

On license price alone, Twenty Pro is roughly ten times cheaper than HubSpot Professional for this team size, and Twenty Organization undercuts HubSpot Enterprise by nearly 4 times while including the SSO and permissions HubSpot reserves for its top tier. The honest counterweights: HubSpot bundles a marketing platform Twenty does not have, a far larger integration marketplace, and two decades of ecosystem. Twenty is the younger product, and that shows in places like the one recipient email limit. We run the full numbers, including seats, onboarding, and the features each tier unlocks, in Twenty CRM vs HubSpot: the real cost for a 20 person sales team. If the comparison pushes you toward switching, how to migrate from HubSpot to Twenty CRM walks the process step by step. If you self-host Twenty, the software is free and you pay only for the infrastructure and the people running it; we break those operating costs down in how to self-host Twenty CRM.

When Twenty workflows are the wrong choice

Be suspicious of any tool that claims to fit everything. Twenty workflows are the wrong choice when:

• You need hundreds of prebuilt app connectors. Zapier and Make ecosystems dwarf what Twenty connects natively today. Keep Twenty for CRM logic and let n8n or Make handle the long tail.
• You need marketing automation. Bulk campaigns, landing pages, lead scoring across web behaviour: that is HubSpot Marketing Hub or a dedicated tool like Listmonk, not Twenty workflows.
• You need multi-recipient or richly formatted automated email. One recipient per Send Email action and no HTML signatures are documented limits. Draft-and-review works around some of this, not all.
• Your inbound webhook carries sensitive data today. Trigger authentication is still on the roadmap.
• You are migrating a decade of Salesforce automation in one quarter. The visual builder is capable but young; complex legacy process trees deserve a phased rebuild, not a weekend port.

Frequently asked questions

Is Twenty workflow automation free? If you self-host the open source core, yes: the full workflow engine is included and you pay only for your own infrastructure. On Twenty Cloud, automations are included in every plan with a workflow credit allocation, and heavy Code or AI usage may require credit packs at $1 per credit.

Can Twenty replace Zapier or Make? For automation that lives entirely inside the CRM, usually yes. For workflows spanning many external apps, no: pair Twenty's webhooks with n8n or Make instead. Many teams end up with Twenty handling CRM logic and n8n handling system-to-system glue.

Does Twenty have an API? Yes. Every workspace gets REST and GraphQL APIs generated from its own schema, including custom objects, plus a metadata API for schema management. Batch operations handle up to 60 records per request, and GraphQL supports batch upserts.

Can external apps trigger a Twenty workflow? Yes, through the webhook trigger, which gives each workflow a unique URL accepting GET or POST requests. You declare the POST body structure up front. Authentication on these endpoints is marked as coming soon, so treat the URL as a secret for now.

What happens when I run out of workflow credits? You buy more in Settings then Billing. Since 1 credit equals $1 of usage, topping up is simply adding dollars to your balance. Watch the per-action breakdown in Settings then Billing during your first month so a heavy Code or AI workflow does not surprise you.

How mature is Twenty compared with Salesforce or HubSpot? Younger, but moving fast: the GitHub repository shows tens of thousands of commits and near-daily activity, and the project positions itself as the leading open source CRM. Expect a capable core with some rough edges rather than a feature-for-feature match with incumbents.

Where to go from here

Start with the workflow that annoys your team most this week: lead follow-up, stale opportunity nudges, or meeting-booking notifications are all thirty minute builds with the patterns above. If you would rather have Twenty deployed, integrated with your mail, calendar, and the rest of your stack, and run for you, take a look at our managed open source stack service and talk to an engineer about your setup.