How to Migrate from HubSpot to Twenty CRM

HubSpot's free CRM works until you need marketing, sales, or service hubs — then pricing jumps to $20-120+/user/month. Twenty is the modern open source CRM — Notion-like UX, GraphQL API, and full data ownership. Here's how to migrate.

Step 1: Deploy Twenty

# Docker Compose
git clone https://github.com/twentyhq/twenty.git
cd twenty
cp .env.example .env
# Configure DATABASE_URL, REDIS_URL, etc.
docker compose up -d

Access at localhost:3000 and create your workspace.

Step 2: Export from HubSpot

Contacts:

1. HubSpot → Contacts → Actions → Export
2. Select all properties or choose specific ones
3. Download CSV

Companies:

1. HubSpot → Companies → Actions → Export
2. Download CSV

Deals:

1. HubSpot → Deals → Actions → Export
2. Download CSV

Step 3: Import into Twenty

Twenty supports CSV import:

1. Open Twenty → Settings → Data Model
2. Verify your object fields match HubSpot's export columns
3. Go to the People or Companies view
4. Click Import → Upload CSV
5. Map columns to Twenty fields

Field mapping:

HubSpot	Twenty
First Name	firstName
Last Name	lastName
Email	email
Phone	phone
Company	company (relation)
Job Title	jobTitle
City	city
Lifecycle Stage	Custom field
Lead Score	Custom field

Step 4: Set Up Pipeline

1. Go to Settings → Data Model → Opportunities
2. Create pipeline stages matching HubSpot:

HubSpot Stage	Twenty Stage
Appointment Scheduled	Meeting Scheduled
Qualified to Buy	Qualified
Presentation Scheduled	Demo
Decision Maker Bought-In	Negotiation
Contract Sent	Proposal Sent
Closed Won	Won
Closed Lost	Lost

Step 5: Configure Custom Fields

Twenty uses a flexible data model. Add custom fields to match HubSpot properties:

1. Settings → Data Model → select object (People, Companies)
2. Add Field → choose type (text, number, date, select, relation)
3. Map your HubSpot custom properties

Step 6: Set Up Integrations

HubSpot Feature	Twenty Equivalent
Email tracking	Email integration (coming)
Meeting scheduling	Calendar sync
Forms	Webhooks + API
Workflows	API-based automation
Reporting	Analytics views
Email sequences	Not yet (roadmap)
Live chat	Not included (use Chatwoot)

Twenty's API is GraphQL — powerful for building custom integrations:

mutation {
  createPerson(data: {
    name: { firstName: "Jane", lastName: "Doe" }
    email: { primaryEmail: "jane@example.com" }
    company: { connect: { id: "company-id" } }
  }) {
    id
  }
}

What You'll Gain

• Full data ownership — your CRM data on your server
• Modern UX — Notion-like interface, keyboard shortcuts
• GraphQL API — powerful, typed API for automation
• No per-user pricing — unlimited users
• Custom data model — add any fields or objects
• Open source — AGPL-3.0, active development

What You'll Lose

• HubSpot's marketing hub (emails, forms, landing pages)
• Sales sequences and automation
• Built-in reporting dashboards
• App marketplace integrations
• Customer support ticketing

Cost Comparison

Users	HubSpot Starter	Twenty Self-Hosted	Savings
5	$100/month	$15/month	$1,020/year
10	$200/month	$25/month	$2,100/year
25	$500/month	$40/month	$5,520/year

Migration Timeline

Week	Task
Week 1	Deploy Twenty, export HubSpot, import contacts/companies
Week 2	Set up pipeline, custom fields, integrations
Week 3	Train team, run both CRMs
Week 4	Full cutover, archive HubSpot

What to Do About HubSpot's Marketing Features

The biggest objection to leaving HubSpot is the marketing hub. HubSpot's email marketing, landing pages, and automation sequences are genuinely good, and the free and Starter tiers are what most small teams start with. Twenty is a CRM, not a marketing platform, so some feature replacement is necessary.

For email marketing, the open source alternatives that pair well with Twenty include Listmonk (self-hosted newsletter and transactional email with PostgreSQL backend), Mautic (full marketing automation platform, more complex to run), and Sendy (not open source but extremely cheap for sending via SES). Listmonk is the most common choice for teams migrating from HubSpot's email features — it handles subscriber management, campaigns, and tracking without any per-email cost beyond your SES or SMTP provider fees.

Landing pages can be handled by your existing website infrastructure. Most teams using HubSpot landing pages were using them because HubSpot made it easy, not because they specifically needed HubSpot-native pages. Static site generators, your existing CMS, or tools like Webflow cover this use case adequately.

Workflow automation — HubSpot's sequences and deal-based triggers — requires a dedicated automation tool. This is where combining Twenty with n8n creates a powerful open source alternative to HubSpot's full platform. Migrating from Zapier to n8n covers how to set up n8n for exactly this kind of CRM-adjacent automation. You can build sequences that send emails when a deal moves to a new stage, create tasks when a contact hasn't been touched in 30 days, or sync new contacts from your web forms directly into Twenty's People database — all without paying HubSpot's $800+/month Sales Hub pricing for the same capabilities.

Twenty's GraphQL API is what makes this integration practical. Unlike CRMs that hide their data behind proprietary sync connectors, Twenty's API is typed, well-documented, and designed for automation. An n8n workflow that listens to Twenty webhooks and triggers multi-step actions runs reliably without the fragility of screen-scraping or undocumented API endpoints.

For reporting and analytics beyond what Twenty's built-in views provide, tools like Metabase or Apache Superset can connect directly to Twenty's PostgreSQL database (with appropriate read-only credentials) and build dashboards on top of your CRM data. This gives you HubSpot-quality reporting without the HubSpot price tag, and with full control over the queries that drive your pipeline metrics.

Running Twenty in Production: Infrastructure and Maintenance

Twenty's Docker Compose setup gets you running quickly, but production deployments need a few additional considerations that the quick-start documentation doesn't cover in depth.

Database configuration is the first thing to address. Twenty uses PostgreSQL, and for any serious CRM workload you want to run PostgreSQL outside of the Docker network with automated backups, connection pooling via PgBouncer, and monitoring. Using a managed PostgreSQL service (Neon, Railway, or your VPS provider's managed database) removes the database maintenance burden from your team. For teams comfortable with self-hosting everything, automated server backups with Restic and Rclone covers how to ensure your PostgreSQL data is backed up with encryption and offsite replication.

The deployment platform matters for the maintenance experience. If you're running Twenty on Coolify or Dokku, you get automatic zero-downtime deployments when new Twenty releases are published. Coolify users can connect Twenty's Git repository and set up automatic builds on new tags. Dokku users can update with docker pull followed by a container restart. Both approaches take under five minutes once the initial setup is done.

User onboarding is often the hardest part of any CRM migration. Twenty's Notion-like interface is intuitive for teams familiar with modern tools, but it's different enough from HubSpot's layout that a brief orientation session is worth scheduling. The most important things to cover: how the data model works (People, Companies, Opportunities as first-class objects with relations), how to create custom fields for HubSpot properties that don't have direct equivalents, and how to use the search and filtering system to replicate the saved views your team relied on in HubSpot.

The open source CRM landscape is broader than just Twenty. If you find that Twenty's current feature set is missing something critical for your workflow, alternatives like Vtiger, EspoCRM, or SuiteCRM offer different trade-offs. Our best open source CRM software guide covers the full landscape. But Twenty's modern architecture, active development pace, and GraphQL API make it the strongest choice for teams starting a migration in 2026. The roadmap — email sequences, enhanced reporting, mobile apps — suggests the feature gaps that exist today will close within 12-18 months.

Financial Impact: Beyond the Monthly Cost Comparison

The cost table in the migration overview tells part of the story. But the full financial picture of moving from HubSpot to Twenty is more nuanced than the monthly subscription delta.

HubSpot's pricing structure has a compounding problem: the more your team grows, the more expensive it gets. Adding a new sales rep to HubSpot Starter adds $20/month per user immediately. Adding them to a self-hosted Twenty deployment has zero marginal cost. For teams that are actively hiring into sales or business development roles, this asymmetry becomes significant within a year. A team that goes from 5 to 15 sales-adjacent staff on HubSpot Starter during a growth phase pays an additional $200/month they wouldn't pay with Twenty.

Data export and portability also has financial value that doesn't appear in the monthly comparison. With HubSpot, your contact data, deal history, and custom properties are accessible via export, but the format is proprietary and re-importing to another tool requires mapping work. With Twenty and PostgreSQL, your data is directly queryable, trivially exportable in any format, and readable by any tool that supports SQL or GraphQL. This eliminates future migration costs if Twenty is ever replaced, and it enables ad hoc analysis that HubSpot's reporting tools would charge premium tier pricing for.

The SaaS subscription audit perspective is valuable context here. Teams that conduct a systematic review of their SaaS spending often discover that CRM costs, once marketing hubs and add-ons are accounted for, are among the top three line items. HubSpot's pricing is designed to grow with your revenue and headcount — features you need for a growing sales team are precisely the ones that push you from the free tier to Starter to Professional. Twenty's flat infrastructure cost means your CRM spending scales only with your server costs, not with your business success.

For a broader view of where CRM fits in the open source software landscape, the best open source CRM software 2026 guide evaluates Twenty alongside Vtiger, EspoCRM, Corteza CRM, and other alternatives. The comparison is useful for teams that have specific requirements — field sales teams needing mobile CRM apps, support teams needing integrated ticketing, or organizations needing ERP-level integration — that might be better served by a different open source CRM than Twenty.

Team adoption is often the factor that determines whether a CRM migration succeeds or fails technically but fails organizationally. HubSpot has spent years optimizing its UI for sales team workflows, and muscle memory around how deals are created, updated, and moved through the pipeline is real. Scheduling a 30-minute hands-on workshop where the sales team does their usual weekly pipeline review in Twenty — before the hard cutover — is more effective than any documentation or training video. Finding the team member most resistant to the change and addressing their specific concerns directly, ideally by showing them how Twenty handles the exact workflows they rely on, removes the most common source of organizational resistance to CRM migrations.

The API-first architecture of Twenty is particularly valuable for teams that build internal tooling. Rather than waiting for a HubSpot feature request to be prioritized by a product team operating on commercial incentives, Twenty's GraphQL API means you can add the exact feature your team needs as an internal integration or a custom automation via n8n. This developer-first flexibility is the deepest form of the "data ownership" benefit — it's not just that you own the data, it's that you control the product roadmap for your CRM experience, subject only to the constraints of what PostgreSQL and GraphQL can express.

---

Compare CRM platforms on OSSAlt — features, data model flexibility, and pricing side by side.

See open source alternatives to HubSpot on OSSAlt.