Twenty CRM: Open-Source Salesforce Alternative With AI Agents

Twenty is an open-source, AI-powered CRM platform that runs on your own infrastructure through Docker Compose or as a managed cloud service at $9 per user per month.

It stores your pipeline, contacts, tasks, and custom data models in a PostgreSQL database you control directly, with a React and TypeScript front end your team can extend through a published apps framework.

Your CRM holds deals, contacts, tasks, and pipeline stages that your business depends on. A CRM that walls off custom objects, API access, or advanced permissions behind escalating price tiers shifts the friction from the sales process to the software itself.

Twenty splits that pattern by running on the same TypeScript and PostgreSQL you already use, packaged as a CRM where the self-hosted path costs nothing beyond your infrastructure, and the managed cloud version starts at a flat $9 per user per month with no feature gating on custom objects or API access.

Features

• Tracks people, companies, opportunities, notes, and tasks as standard CRM objects.
• Adds custom objects and custom fields for nonstandard business data.
• Organizes records with table, Kanban, and calendar views.
• Imports and exports CRM data through CSV and API workflows.
• Syncs emails and calendar events to core CRM records.
• Creates workflows with record, schedule, manual, and webhook triggers.
• Extends workspaces with TypeScript apps, custom objects, UI components, logic functions, views, and AI entities.
• Connects external systems through REST APIs, GraphQL APIs, webhooks, and OAuth.
• Uses roles, two-factor authentication, field permissions, and plan-based row-level permissions.
• Includes AI-agent and MCP paths for advanced CRM automation, but the CRM and app framework remain the safer evaluation points today.

Use Cases

• Build a self-hosted CRM for sales, partnerships, recruiting, or customer success.
• Replace spreadsheet-based deal tracking with records, views, dashboards, notes, and tasks.
• Model custom business data such as subscriptions, events, projects, batches, or partner programs.
• Sync CRM changes into internal tools through REST APIs, GraphQL APIs, or signed webhooks.
• Build CRM extensions with TypeScript when no-code settings no longer cover the workflow.
• Prepare AI-assisted CRM processes with controlled data permissions and workspace roles.

How to Use Twenty

Choose Cloud or Self-Hosted

Use Cloud when the team wants managed hosting, workspace setup, billing, and updates handled by Twenty.

Use self-hosting when data ownership, infrastructure control, or private deployment matters more than managed operations.

Start with the Core CRM Objects

Create or import your core records first: people, companies, opportunities, notes, and tasks. Keep people, companies, and opportunities as the center of the model because synchronized emails and meetings attach to those core objects.

Add Custom Objects Only When the Data Needs Its Own Lifecycle

A custom field is enough for a label, category, status, or one-off attribute. A custom object makes more sense for data with its own owner, dates, stages, relationships, or repeated records.

A subscription, project, event, partner program, product, or cohort usually deserves its own object. A simple company category should stay as a field.

Create Views for Daily Work

Use table views for record review, Kanban views for pipeline movement, and calendar views for date-based records. Create separate views for sales, operations, leadership, and account management instead of forcing every role into one default list.

Connect Email and Calendar Carefully

Email and calendar sync can make a CRM useful quickly, but the sync behavior matters most on people, companies, and opportunities. Keep customer communication near those records before you scatter related data across many custom objects.

Build Workflows Around Repeatable Events

Create workflows for record creation, record updates, schedules, manual triggers, and incoming webhook events. Start with a narrow workflow such as lead assignment, renewal reminder creation, or follow-up task generation before you add filters, iterators, HTTP requests, or code steps.

Use APIs and Webhooks for System Integration

Create an API key under Settings → API & Webhooks when another system needs CRM access. Copy the key immediately because it appears once. Assign API access through roles when the integration should not access every object.

Use webhooks when an external system needs record-change events. Twenty sends signed HTTP POST requests for create, update, and delete events across standard and custom objects.

Use the App Framework for Versioned Extensions

Use the TypeScript app framework when settings-based customization no longer covers the workflow. A Twenty app can define objects, fields, logic functions, front components, skills, agents, views, navigation items, page layouts, and command menu actions.

Self-Hosted Installation Commands

Install the latest stable self-hosted version with the one-line script.

bash <(curl -sL https://raw.githubusercontent.com/twentyhq/twenty/main/packages/twenty-docker/scripts/install.sh)

Install a specific version or branch.

VERSION=vx.y.z BRANCH=branch-name bash <(curl -sL https://raw.githubusercontent.com/twentyhq/twenty/main/packages/twenty-docker/scripts/install.sh)

Create the environment file during manual setup.

curl -o .env https://raw.githubusercontent.com/twentyhq/twenty/refs/heads/main/packages/twenty-docker/.env.example

Generate an encryption key.

openssl rand -base64 32

Set the encryption key in .env.

ENCRYPTION_KEY=random_string

Set the PostgreSQL password in .env.

PG_DATABASE_PASSWORD=my_strong_password

Download the Docker Compose file.

curl -o docker-compose.yml https://raw.githubusercontent.com/twentyhq/twenty/refs/heads/main/packages/twenty-docker/docker-compose.yml

Start the Docker containers.

docker compose up -d

Check a server-hosted deployment from the machine.

curl http://localhost:3000

Configure direct external access.

SERVER_URL=http://your-domain-or-ip:3000

Configure domain access behind a reverse proxy with SSL.

SERVER_URL=https://your-domain-or-ip

Configure custom-port access.

SERVER_URL=https://your-domain-or-ip:custom-port

Restart the Docker containers after SERVER_URL changes.

docker compose down
docker compose up -d

Backup, Restore, and Upgrade Commands

Create a database backup from the default Twenty PostgreSQL container.

docker exec twenty-postgres pg_dump -U postgres twenty > backup_$(date +%Y%m%d).sql

Add a daily backup job through crontab.

0 2 * * * docker exec twenty-postgres pg_dump -U postgres twenty > /backups/twenty_$(date +\%Y\%m\%d).sql

Stop the frontend and server before a restore.

docker compose stop twenty-server twenty-front

Restore a database backup.

docker exec -i twenty-postgres psql -U postgres twenty < backup_20240115.sql

Restart services after a restore.

docker compose up -d

Create a full PostgreSQL backup before an upgrade.

docker exec -it {db_container_name_or_id} pg_dumpall -U {postgres_user} > databases_backup.sql

Restore a full PostgreSQL backup.

cat databases_backup.sql | docker exec -i {db_container_name_or_id} psql -U {postgres_user}

Upgrade a Docker Compose deployment.

docker compose down

Change the TAG value in the .env file next to docker-compose.yml, then restart.

docker compose up -d

App Framework Commands

Enable Yarn through Corepack before app development.

corepack enable

Scaffold a Twenty app.

npx create-twenty-app@latest my-twenty-app

The older short form also appears in Twenty setup examples.

npx create-twenty-app my-app

Move into the app directory.

cd my-twenty-app

Run the live app sync loop.

yarn twenty dev

Run a one-shot build and sync.

yarn twenty dev --once

Preview metadata changes without writing them.

yarn twenty dev --once --dry-run

Publish an app privately.

npx twenty app:publish --private

Twenty vs Salesforce, HubSpot, and Normal No-Code CRMs

Twenty is not just a cheaper contact database. Its real difference appears when the CRM must change with the business model.

Salesforce has deeper enterprise history, a larger marketplace, and a broad admin ecosystem. It also brings licensing complexity, implementation cost, and proprietary platform decisions. Twenty gives technical teams a cleaner route when TypeScript, APIs, self-hosting, and object-level customization matter more than a mature enterprise app marketplace.

HubSpot is easier for marketing, CRM onboarding, and packaged growth workflows. Twenty is more appropriate when your CRM data model needs custom objects, code-defined extensions, private infrastructure, or API-first ownership.

Airtable and Notion can mimic lightweight CRM workflows quickly. Twenty becomes the better long-term option when email sync, calendar sync, roles, workflows, APIs, and CRM-specific records need to live inside one structured system.

Pricing and Plans

Alternatives and Related Resources

• Twenty Documentation: Read the platform overview, user guide, developer docs, and self-hosting guide.
• Twenty GitHub Repository: Inspect the source code, issues, pull requests, and project activity.
• Twenty User Guide: Learn the CRM data model, workflows, permissions, billing, dashboards, and settings.
• Best AI Agents: Compare AI agents if the AI automation angle matters more than CRM infrastructure.

Pros

• Free self-hosted plan.
• Open-source core.
• REST and GraphQL APIs.
• Custom objects and views.
• CSV import and export.
• Webhook event delivery.

Cons

• Self-hosting needs maintenance.
• Cloud requires paid seats.
• Enterprise files use separate licensing.
• Row-level permissions need Organization.

FAQs

Q: Does Twenty replace Salesforce?
A: Twenty can replace Salesforce for teams that need a customizable CRM, self-hosting, TypeScript extensions, and API access. Salesforce still has a larger enterprise ecosystem, more mature packaged modules, and broader consultant coverage.

Q: Does Twenty require coding?
A: Basic CRM setup does not require coding because admins can create custom objects, custom fields, views, and workflows from settings. Coding becomes relevant when you build TypeScript apps, custom UI components, logic functions, or advanced integrations.

Q: Can I self-host Twenty in production?
A: Twenty supports production self-hosting through Docker Compose. A production deployment needs Docker, Docker Compose, at least 2GB of RAM, persistent storage, HTTPS, backups, and a correct SERVER_URL.

Q: Can I migrate from Salesforce or HubSpot to Twenty?
A: You can import contacts, companies, deals, and custom records through CSV import or the REST API, which handles batches of 50,000 or more records. Field mapping, relationship preservation, and activity history migration require manual planning because the data models differ between platforms.

Q: How does the MCP server work with AI assistants?
A: Every Cloud workspace runs a native MCP server. You connect Claude, ChatGPT, or Cursor to it through OAuth from the AI tool’s MCP configuration panel. Once connected, the AI assistant can read records, create contacts, update deal stages, run queries, and generate reports against your live CRM data using natural-language instructions.

Q: What happens to my data if Twenty the company stops operating?
A: Your data lives in your own PostgreSQL database. You can export it at any time through pg_dump, the REST API, or CSV export.