Pipedrive to ActiveCampaign Migration: A Technical Guide

Pipedrive to ActiveCampaign Migration: A Technical Guide

Migrating from Pipedrive to ActiveCampaign is a schema translation problem, not a CSV upload. Pipedrive is a deal-centric CRM built for outbound sales pipelines — Deals sit at the center of day-to-day work, with Persons, Organizations, Activities, Notes, and Files fanning out from them. ActiveCampaign is a contact-and-tag-centric automation platform where Contacts are the primary object, Accounts represent companies, Deals live inside Pipelines, and the automation engine drives most of the platform's value.

A CSV export from Pipedrive gets contact and deal records across, but it breaks every relational link between objects, drops notes from the main export, and carries zero automation logic. ActiveCampaign's native Pipedrive integration is even more limited — it only syncs contact fields, runs every 30 minutes, and does not transfer deals, notes, activities, or pipeline history. (help.activecampaign.com)

Understanding the structural mismatch between these two platforms before writing a single line of migration code is what separates a clean cutover from months of cleanup.

This guide covers the architectural differences, field mapping, API constraints, extraction and loading patterns, and the edge cases that break most DIY migrations. If you're evaluating other Pipedrive migration targets, see our migration guides for HubSpot, GoHighLevel, Attio, or Salesforce.

Pipedrive vs ActiveCampaign: Data Model Differences

The architectures look similar on the surface — both have contacts, deals, and pipelines. The structural differences are what make the migration hard.

Pipedrive is deal-centric. The core entities are Organizations, Persons, Deals, Leads, Activities, and Products. Every activity, note, email, and file fans out from a Deal or its linked contact. Leads live in a separate Leads Inbox and cannot be accessed via the standard Deals API endpoints. Pipedrive does not support custom objects — it supports custom fields across standard entities, each assigned a random 40-character hex hash as its API key. (pipedrive.readme.io)

ActiveCampaign is contact-and-tag-centric. The standard objects are Contacts, Accounts, and Deals. Contacts are the center of gravity — automations, campaigns, and tracking revolve around the Contact record. Tags and list memberships drive segmentation and automation triggers. ActiveCampaign offers only six default contact fields (Email, First Name, Last Name, Phone, Organization, Job Title) but supports unlimited custom fields. Custom Objects are available on Enterprise plans and can be created via the API or the Manage Data UI; Plus and Professional plans can receive custom objects only from supported third-party integrations and cannot create arbitrary custom object schemas. (developers.activecampaign.com)

Here's the object-level mapping:

Why Teams Move from Pipedrive to ActiveCampaign

This is not a lateral CRM swap — it's a shift from a sales-pipeline tool to a marketing-automation-first platform with CRM capabilities. The migration drivers usually fall into two categories:

• Marketing automation gap. Pipedrive's built-in email features (Pipedrive Campaigns) are limited to basic broadcasts and simple automations. ActiveCampaign's automation builder supports conditional branching, split testing, predictive sending, lead scoring, and multi-channel orchestration across email, SMS, and WhatsApp. Teams that outgrow Pipedrive Campaigns typically cite the absence of behavioral triggers and dynamic segmentation as the primary gaps.
• Contact-centric lifecycle management. Pipedrive tracks deals through stages. ActiveCampaign tracks contacts through lifecycle stages, engagement scoring, and tag-driven automation sequences. If your business depends on nurturing contacts across months or years — post-sale onboarding, renewal sequences, re-engagement — ActiveCampaign's architecture is a fundamentally better fit than retrofitting Pipedrive with third-party email tools.

Migration Methods: Trade-offs and Constraints

Native Pipedrive Integration

ActiveCampaign's native Pipedrive app is a contact-field sync, not a migration tool. It runs every 30 minutes, does not add synced contacts to a list, and does not automatically push later Pipedrive contact edits unless you restart the sync. It does not transfer deals, notes, activities, or pipeline history. (help.activecampaign.com)

CSV Export/Import

What it covers: Contacts, deals, and organizations as flat files.

What it drops: Notes, activities, file attachments, deal-contact associations, organization-contact links, products on deals, and all automation logic.

The CSV path has specific constraints that matter:

• CSV deal import handles open deals only. Won/lost deals require the API path. (help.activecampaign.com)
• Pipeline and stage names must exactly match existing pipelines and stages in AC — no auto-creation.
• Every deal requires a deal title and deal owner (AC username or email).
• If a deal value is blank, AC defaults it to $100. (help.activecampaign.com)
• CSV deal import cannot attach multiple contacts to one deal or create contact roles.
• Contact imports require an email address or phone number. Duplicate emails cause later rows to be skipped. (help.activecampaign.com)
• If contacts import with an Accounts column, AC assigns those auto-created accounts to the default account owner — not the intended owner. (help.activecampaign.com)

Verdict: Viable for a small team that only needs contacts and basic open deal data. Unacceptable for anyone who needs historical notes, closed deals, activity logs, or deal-contact relationships.

API-to-API Migration (Custom Script)

What it covers: Everything — contacts, accounts, deals, notes, activities (as notes or tasks), file attachments, custom fields, tags, and associations.

What it requires: Engineering time to build extraction scripts against Pipedrive's API and loading scripts against ActiveCampaign's API v3.

This is the only method that preserves relational integrity. The trade-off is engineering effort and rate-limit management on both sides.

iPaaS / Middleware (Zapier, Make)

Tools like Zapier and Make connect Pipedrive triggers to ActiveCampaign actions. They work for ongoing sync but are a poor fit for bulk historical migration:

• Zapier processes records one at a time per Zap execution. Migrating 20,000 deals means 20,000 task executions — expensive and slow.
• Make supports batch operations but still hits the same API rate limits.
• Neither handles Pipedrive's custom field hash resolution natively.

Verdict: Good for keeping platforms in sync post-migration. Not practical for moving historical data at scale.

API Constraints: The Rate-Limit Reality

Rate limits set a hard ceiling on migration throughput. Before writing any migration script, calculate total API calls required and expected wall-clock time at maximum sustained rate.

Pipedrive API

Pipedrive fully migrated to a token-based rate limit (TBRL) system as of 2025. The daily budget is calculated as:

30,000 base tokens × plan multiplier × number of seats

Each endpoint has a different token cost based on computational complexity. Lightweight GET endpoints cost fewer tokens; complex or data-intensive endpoints cost more. A burst rate limit prevents burning the entire daily budget in a short window.

Pipedrive's v2 API uses cursor-based pagination (replacing v1's offset-based pagination), with a maximum of 500 items per page. Cursor pagination is faster for iterating large collections but requires storing the cursor token between requests. When the daily budget runs out, requests receive a 429 Too Many Requests response until the budget resets at midnight. (pipedrive.readme.io)

ActiveCampaign API v3

ActiveCampaign's API v3 has a hard rate limit of 5 requests per second per account. This is an account-wide ceiling shared across all API keys — plan tier does not increase it.

When you exceed the limit, AC returns a 429 response with a Retry-After header. You must implement exponential backoff with a strict request queue. Common error responses to handle:

For high-volume contact loading, AC offers a Bulk Contact Importer API with different constraints:

• Up to 250 contacts per request
• Payload size must be under 400 KB per request
• Handles contact creation, custom field mapping, tag assignment, and list subscription in a single call
• Asynchronous — you submit the payload and poll for completion status
• Automation suppression is controlled via the UI toggle at Contacts → Import → Suppress Automations During Import, not via an API parameter

Migration Time Calculator

Use this model to estimate wall-clock time before you start. Assumptions: 5 req/sec sustained AC load rate, 15% retry overhead, Pipedrive extraction at ~200 records/min on v2 API.

Call count breakdown per record type: Contacts (1 call bulk batch per 250), Accounts (1 call each), Account-Contact links (1 call each), Deals (1 call each), Notes (1 call each). Extraction from Pipedrive adds 30–60% additional time depending on token budget and data volume.

This model informs the DIY vs. professional help decision below. At 10,000+ contacts with full relational data, you're looking at a full business day of continuous API throughput with zero margin for errors.

Custom Field Mapping: The Hard Part

Field mapping is where most migrations silently lose data. The table below maps every Pipedrive field type to its closest ActiveCampaign equivalent and flags conversion requirements.

Pipedrive vs ActiveCampaign Field Type Compatibility Matrix

Key implications:

• Multi-currency deals require a custom text field for currency code alongside the deal value field. There is no native multi-currency support in AC deals.
• Set fields with values like Red|Green|Blue in Pipedrive export to Red||Green||Blue in AC's listbox format — the separator changes.
• Monetary fields on Contact records (e.g., "Lifetime Value" on a Person) must be stored as text in AC, losing numeric sorting and filtering.

Before pulling any records, extract all custom field definitions from the PersonFields, OrganizationFields, and DealFields endpoints. You need this lookup table to translate hash keys to human-readable names.

# Fetch all person custom fields from Pipedrive
import requests
 
headers = {"x-api-token": PIPEDRIVE_API_TOKEN}
response = requests.get(
    f"https://{COMPANY_DOMAIN}.pipedrive.com/api/v2/personFields",
    headers=headers,
    params={"limit": 500}
)
field_map = {
    f["key"]: f["name"] 
    for f in response.json()["data"] 
    if f.get("edit_flag")
}

Not every Pipedrive field deserves a counterpart in AC. Build a mapping spreadsheet with four columns: Pipedrive Field Hash, Pipedrive Field Name, AC Target Field, Action (map / transform / skip). This document becomes the source of truth for your transformation layer. (pipedrive.readme.io)

Extraction Architecture: Getting Data Out of Pipedrive

The extraction sequence matters. Pipedrive's relational model means you need to resolve IDs before you can map associations in ActiveCampaign.

Step 1: Extract Field Definitions. Pull all custom field definitions from PersonFields, OrgFields, and DealFields. Build the hash-to-name lookup table. This must happen before you pull any records — without it, your exported data is a wall of hex strings.

Step 2: Extract Organizations. Pull all Organizations first. You'll need Org IDs to resolve the Organization link when extracting Persons and Deals.

Step 3: Extract Persons. Extract Persons with their custom fields. Each Person record includes an org_id linking to the parent Organization. Pipedrive allows multiple phone numbers and emails per Person in an array format — you'll need to flatten these later.

Step 4: Extract Deals. Deals link to both Persons (person_id) and Organizations (org_id). Extract with pipeline and stage information — you'll need the pipeline name and stage name for AC import. Note that Pipedrive allows Deals to exist without a linked Person (tied only to an Organization).

Step 5: Extract Notes and Activities. Notes and activities link to Deals, Persons, or Organizations by their respective IDs. Pipedrive Notes are polymorphic — they can be attached to a Person, Organization, or Deal. Pipedrive's CSV export does not include notes in the contact or deal export — they must be pulled via API. Extract per-entity and preserve all association metadata. (support.pipedrive.com)

Step 6: Extract Files (if needed). File attachments are stored per-deal or per-person. Pipedrive's file download endpoint returns binary content. Note that files stored in Google Drive are not available through the API export.

Store all extracted data in a staging database (PostgreSQL or MongoDB) rather than holding it in memory. This gives you a rollback point, lets you run verification queries against the source data, and allows you to perform complex joins to verify relationships before loading.

Loading Architecture: Getting Data Into ActiveCampaign

The loading sequence is critical. ActiveCampaign requires records to exist before you can associate them.

Prerequisite Setup

Before loading any records:

1. Create all custom fields (contact, account, deal) in AC — including hidden fields for source IDs.
2. Create pipelines and stages — names must match exactly for deal import.
3. Create lists — contacts must be subscribed to at least one list for email marketing.
4. Map user ownership — Pipedrive deal/contact owners to AC user assignments.
5. Create source ID fields (pipedrive_person_id, pipedrive_org_id, pipedrive_deal_id) as hidden custom fields. These enable idempotent reruns: if a batch fails halfway through, you can requery AC by the source ID field, compare against your staging database, and resume loading only unprocessed records — avoiding duplicates without a full reload.

Load Order

1. Load Accounts (from Pipedrive Organizations) — POST /api/3/accounts. Store the mapping of Pipedrive Org ID → AC Account ID in your staging database.
2. Load Contacts (from Pipedrive Persons) — Use the Bulk Contact Importer for volume. Apply tags during import (including a Pipedrive Import tag for easy identification and cleanup). Store the Pipedrive Person ID → AC Contact ID mapping.
3. Link Contacts to Accounts — POST /api/3/accountContacts with the AC Account ID and Contact ID. This is a separate API call — the association is not created automatically during contact import.
4. Load Deals — POST /api/3/deals. Each deal requires a contact ID (the AC contact ID, not Pipedrive's), group (pipeline ID), stage, owner, and title. Pass the new AC Contact and Account IDs from your mapping tables. AC strongly prefers deals linked to a Contact — if you have orphaned deals in Pipedrive (tied only to an Organization), either create placeholder Contacts or adjust your pipeline settings.
5. Load Notes — Contact notes via POST /api/3/notes (specifying relid and reltype), deal notes via POST /api/3/deals/{id}/notes. One API call per note — this is the slowest phase for note-heavy accounts. Resist the urge to collapse years of notes into one mega-note per deal. It finishes faster but makes the history unsearchable for users.
6. Load Activities as Tasks or Notes — Map completed Pipedrive activities as timestamped notes (appending activity type, date, and outcome to the note body). Map open/future activities as deal tasks or contact tasks. ActiveCampaign task types are configurable per account, so normalize Pipedrive activity types before load rather than assuming a one-to-one label match. (developers.activecampaign.com)

Rollback and Recovery Pattern

Partial failures are the norm, not the exception. Here is the recovery pattern using source ID custom fields:

# Check which AC contacts were already created in a previous run
# Query AC for contacts where pipedrive_person_id is set
import requests
 
def get_already_loaded_contacts(ac_api_url, ac_api_key, batch_of_pipedrive_ids):
    """Returns a dict of {pipedrive_person_id: ac_contact_id} for already-loaded records."""
    loaded = {}
    for pid in batch_of_pipedrive_ids:
        resp = requests.get(
            f"{ac_api_url}/api/3/contacts",
            headers={"Api-Token": ac_api_key},
            params={"fieldid": PIPEDRIVE_PERSON_ID_FIELD_ID, "fieldvalue": pid}
        )
        results = resp.json().get("contacts", [])
        if results:
            loaded[pid] = results[0]["id"]
    return loaded
 
# In your main load loop:
# 1. Pull batch of Pipedrive persons from staging DB
# 2. Check which are already in AC via source ID lookup
# 3. PATCH existing records, POST new ones
# 4. Update staging DB with AC IDs after each successful write

This pattern lets you rerun the migration script after any failure without creating duplicates. The staging database is your checkpoint — it records AC IDs as each record is successfully created, so rerun logic skips already-processed records.

Edge Cases and Failure Modes

Even with a solid script, platform-specific edge cases will cause failures if you don't account for them.

Email Uniqueness and Deduplication

ActiveCampaign enforces strict email uniqueness for Contacts and returns a 422 Unprocessable Entity error when you attempt to create a second Contact with an existing email address. Pipedrive allows multiple Persons to share the same email (e.g., info@company.com). Deduplicate in your transformation layer before loading. Watch for role accounts (sales@, info@), recycled phone numbers, and generic company aliases. For role accounts shared across multiple Persons, pick the most recent or most active Person as the canonical contact and store the others as notes or merged records. (help.activecampaign.com)

Owner Drift

Default-owner fallbacks on account creation can quietly reroute ownership. If an account import contains a bad owner value, AC assigns the default account owner. If contacts auto-create accounts via an Accounts column during CSV import, those accounts also get the default owner. For territory routing and account-based workflows, this silent drift breaks downstream logic. Always import accounts explicitly before contacts if owner accuracy matters. (help.activecampaign.com)

Bounced and Unsubscribed Contacts

If a contact unsubscribed or bounced in Pipedrive, you must migrate that status. Use POST /api/3/contactLists with status: 2 (Unsubscribed) to explicitly set subscription status for your master lists. Failing to do so exposes you to CAN-SPAM and GDPR violations on your first send from AC.

Pipedrive Leads Without a Home

Pipedrive's Leads Inbox is a separate data silo. ActiveCampaign has no distinct Lead object. Two options:

• Tagging: Migrate Leads as AC Contacts and apply a Status: Lead tag.
• Pipeline Staging: Migrate Leads as Deals in a dedicated "Lead Qualification" pipeline.

The pipeline approach is usually the better fit, because it lets you use AC's deal-based automations to nurture leads before moving them to a primary sales pipeline.

Products on Deals

Pipedrive supports Products as line items on Deals (quantity, price, discount). AC has no native product-on-deal model. Options by plan tier:

Neither non-Enterprise approach preserves the multi-line-item structure. If product-level reporting matters post-migration, Enterprise custom objects are the only path that doesn't require a separate external system.

Deal Participants and Stakeholders

Pipedrive deals have one linked Person by default, and many teams model extra stakeholders using custom person or organization fields. AC deals require a primary contact but support secondary contacts through the contactDeals endpoint. If you want a usable sales record after go-live, promote those extra stakeholders into real Contacts and attach them as secondary contacts rather than burying them in note text. (support.pipedrive.com)

Multi-Currency Deals

Pipedrive stores deal value and currency code as separate fields (e.g., value: 50000, currency: "EUR"). ActiveCampaign's deal value is a single field in your account's default currency. To preserve multi-currency data:

1. Create a custom deal text field: Original_Currency (e.g., "EUR").
2. Create a custom deal text field: Original_Value (e.g., "50000").
3. Load the converted value (in your AC account's default currency) into the AC deal value field for pipeline reporting.
4. Store the original currency and value in the custom fields for reference.

Without this pattern, all deal values appear in your AC account currency and the original currency is permanently lost.

File Attachments

AC supports file attachments on deal, contact, and account records, but with limits — deal file uploads are capped at 75 MB per file, and storage varies by plan tier. If your Pipedrive instance has a heavy archive of proposals and contracts, validate storage math before committing to a full attachment backfill. (help.activecampaign.com)

Automations Cannot Be Migrated

Pipedrive automations and ActiveCampaign automations are entirely different systems with no export/import path between them. Document your Pipedrive automation logic before migration — screenshot every active workflow — and rebuild manually in AC's visual automation builder. Disable all AC automations before loading migration data, then re-enable them only after verifying record integrity.

Email Sending Reputation

If you're moving email marketing from Pipedrive Campaigns to AC, you're changing sending infrastructure. This means new SPF, DKIM, and DMARC records, and a domain warm-up period. Start with small sends to your most engaged contacts (opens in the last 90 days) and ramp up over 2–4 weeks. Do not blast your full list on day one from a cold AC domain — ISPs will throttle or block sends from an unwarmed domain regardless of list quality.

Multi-Value Contact Fields

Pipedrive allows multiple phone numbers and emails per Person in an array format. AC requires a primary email. Write logic to flatten these arrays — select the primary contact method for the main AC fields and push secondary methods into custom text fields.

Pre-Migration Checklist

1. Audit Pipedrive data quality. Merge duplicates, clean dead contacts, close stale deals before migrating — don't pay to move garbage.
2. Map custom fields. Build a four-column spreadsheet: Pipedrive Field Hash, Pipedrive Field Name, AC Target Field, Action (map / transform / skip).
3. Create AC pipelines and stages. Names must match exactly for deal import.
4. Create AC custom fields. All custom fields must exist before loading records — including source ID fields (pipedrive_person_id, pipedrive_org_id, pipedrive_deal_id) for idempotent reruns.
5. Create AC lists. Contacts need at least one list subscription for email marketing.
6. Map user ownership. Pipedrive deal/contact owners → AC user assignments. Resolve every Pipedrive user to a matching AC user before load.
7. Document automations. Screenshot or export every active Pipedrive automation for manual rebuild in AC.
8. Disable AC automations. Turn off all live automations before loading migration data. Re-enable only after record verification.
9. Plan parallel operation. Keep Pipedrive active for 2–4 weeks post-migration until you've verified every record, integration, and workflow in AC.
10. Calculate API budget. Use the migration time calculator above to estimate total AC API calls and wall-clock time before committing to a migration window.
11. Test with a subset. Run the full migration pipeline against 50–100 records first. Validate associations, custom field values, note content, and subscription status before committing to a full run.
12. Validate unsubscribe/bounce status. Confirm suppressed contacts are migrated with status: 2 before your first AC send.

For a platform-agnostic version of this checklist, see our CRM Data Migration Checklist.

When to DIY vs When to Get Help

The decision is primarily a function of data volume and relational complexity. Here's the arithmetic:

At 5 req/sec sustained throughput on the AC side:

• Building the migration script takes an experienced engineer roughly 40–80 hours: extraction layer (Pipedrive API v2, cursor pagination, token budget management), transformation layer (field type mapping, deduplication, association resolution), and loading layer (AC API v3, retry logic, rollback handling).
• Running a migration for 1,000 contacts + 500 deals + 1,500 notes takes ~20 minutes of load time plus engineering oversight.
• Running a migration for 10,000 contacts + 5,000 deals + 30,000 notes takes ~3.5 hours of load time — meaning any error that requires a partial rerun adds hours to the window.

DIY makes sense when:

• You have fewer than 2,000 contacts and 1,000 deals with minimal notes
• You have an engineer available to spend 40–80 hours building and testing the pipeline
• You don't need historical notes or activities (CSV path may suffice)
• Downtime tolerance is high — a multi-day parallel run is acceptable

Professional help makes sense when:

• You have 5,000+ contacts with associated deals, notes, and activities (migration window exceeds what a single engineer can oversee without tools)
• You need to preserve full relational integrity (deal → contact → account links, multi-stakeholder deals)
• You have complex field type mismatches — multi-currency, date ranges, structured addresses
• You can't sustain a 2–4 week parallel run period due to licensing cost or operational friction
• Your team doesn't have Python/API experience and the 40–80 hour engineering estimate is cost-prohibitive

Making It Stick

The Pipedrive-to-ActiveCampaign migration is less about moving records and more about translating a deal-centric sales tool into a contact-centric marketing automation platform. A CSV upload strips your data of its relational context, turning a structured database into a flat list of disconnected names.

Get the data model mapping right first. Extract via API, not CSV. Build the field type compatibility matrix before writing a single load call. Load in dependency order. Store source IDs for idempotent reruns. Disable automations during load. Test with a subset before committing. Keep Pipedrive running until you've verified everything on the other side.