CRM migration
Field-level mapping, validation, and rollback between Oracle Eloqua and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Oracle Eloqua
Source
Twenty CRM
Destination
Compatibility
7 of 10
objects map 1:1 between Oracle Eloqua and Twenty CRM.
Complexity
BStandard
Timeline
4-6 weeks
Overview
Moving from Oracle Eloqua to Twenty CRM is a data-extraction and schema-reconciliation project, not a platform-to-platform parity move. Eloqua's object model centers on Contacts and Accounts as the foundation of a marketing automation environment; Twenty CRM uses a sales-native Contact and Company model with Opportunities, Tasks, and Activities. We extract Eloqua Contacts, Accounts, and Custom Data Objects via the Bulk API with its documented hourly soft limits, map them to Twenty's typed fields, and resolve the lookup relationships that bind them. Campaign orchestration logic, lead scoring models, form configurations, and email asset HTML do not migrate as working records; we document every campaign, automation flow, and scoring weight during discovery and deliver that as a written rebuild guide for your marketing operations team. The migration uses incremental Bulk API jobs chunked under Eloqua's 5 GB file cap, with parent-record resolution ensuring that Account and Contact lookups are satisfied before activity records insert.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a Oracle Eloqua object lands in Twenty CRM, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
Oracle Eloqua
Contact
Twenty CRM
Contact
1:1Eloqua Contacts map directly to Twenty CRM Contacts. Standard fields (first name, last name, email address, phone, title, address) map to Twenty's typed Contact fields. Custom fields from Eloqua's contact field schema migrate to custom fields on the Twenty CRM Contact object. We resolve the EmailAddress field as the dedupe key to prevent duplicate Contacts on re-import. The original Eloqua Contact ID is preserved in a custom field for audit and cross-referencing purposes.
Oracle Eloqua
Account
Twenty CRM
Company
1:1Eloqua Accounts map to Twenty CRM Companies. Account-level fields including industry, website, employee count, and revenue range map to the equivalent Company fields. The account-to-contact relationship is preserved by resolving the parent Company before Contact insert so that the Contact-Company association is established at migration time rather than patched afterward.
Oracle Eloqua
Contact
Twenty CRM
Activity (engagement history)
1:manyEloqua engagement records (email opens, email clicks, form submissions, page visits) are exported as separate activity entries and mapped to Twenty CRM Activity records linked to the corresponding Contact. Each activity record captures the engagement type, timestamp, asset name, and URL. The activity ordering is preserved by setting the Activity date to the original Eloqua event timestamp.
Oracle Eloqua
Custom Data Object (CDO)
Twenty CRM
Custom fields or extension table
1:1Each CDO in Eloqua has its own schema with customer-defined fields. We export CDO records via Bulk API and map them to custom fields on the equivalent Twenty CRM object (Contact, Company, or Opportunity) where the field count is small (under 20 fields). For CDOs with complex schemas or more than 20 fields, we create extension tables in Twenty CRM and link them to the parent record via the original CDO's primary key. This requires pre-designing the extension schema before migration begins.
Oracle Eloqua
Campaign
Twenty CRM
Campaign (documentation only)
1:1Eloqua Campaigns contain multi-step orchestration logic, wait steps, conditions, and trigger configurations that are tightly coupled to Eloqua's execution engine and cannot be exported as working records. We export campaign metadata (name, type, start/end dates, status, targeting criteria) and map campaign membership (which Contacts were added to which campaigns) as a tagged field on the Contact record. The customer's marketing ops team uses the campaign documentation to rebuild in their chosen automation tool.
Oracle Eloqua
Segment and Shared List
Twenty CRM
Contact (tagged)
lossyEloqua Segments define dynamic contact audiences based on filter criteria, and Shared Lists are static contact collections. We export the list membership (the actual Contacts in each segment or list) and tag each Contact with the segment or list names as a multi-value field in Twenty CRM. The dynamic filter logic that defines segment membership cannot be exported and must be reconstructed as a segment or filter in the destination platform.
Oracle Eloqua
Email Asset
Twenty CRM
Activity (documentation)
1:1Email HTML content, subject lines, sender addresses, and metadata are exported from Eloqua's asset library. The HTML is preserved as an attachment or note on the corresponding Activity record in Twenty CRM. Email rendering depends on the destination email tool's template engine and cannot be reconstructed as a working email template. The customer's admin uses the exported HTML as reference content for rebuilding in a new email platform.
Oracle Eloqua
Form
Twenty CRM
Form (documentation)
1:1Eloqua form field configurations (field names, field types, required flags, thank-you page settings) are exported as a JSON document and mapped to a Form documentation record in Twenty CRM. The visual layout and embedded JavaScript of Eloqua forms cannot be exported as working components. The customer's web team uses the field configuration documentation to rebuild forms in their web property or preferred form tool.
Oracle Eloqua
Lead Scoring Model
Twenty CRM
Lead Scoring Model (documentation)
1:1Eloqua's weighted demographic and behavioral lead scoring models are stored in proprietary configuration with no export mechanism. We document the current scoring model structure: which fields contribute, what weights are assigned, what thresholds trigger a score change, and how scores integrate with CRM opportunity data. The customer uses this documentation to implement equivalent scoring logic in their chosen sales or marketing intelligence tool.
Oracle Eloqua
Picklist
Twenty CRM
Picklist (configuration)
lossyEloqua picklists define controlled vocabulary for custom fields. We export picklist definitions (display names and stored values) as a CSV and re-create them as picklist configurations in Twenty CRM where the platform supports picklist fields. This ensures that migrated custom field data uses consistent vocabulary rather than free-text values that would require cleanup after migration.
| Oracle Eloqua | Twenty CRM | Compatibility | |
|---|---|---|---|
| Contact | Contact1:1 | Fully supported | |
| Account | Company1:1 | Fully supported | |
| Contact | Activity (engagement history)1:many | Fully supported | |
| Custom Data Object (CDO) | Custom fields or extension table1:1 | Fully supported | |
| Campaign | Campaign (documentation only)1:1 | Fully supported | |
| Segment and Shared List | Contact (tagged)lossy | Fully supported | |
| Email Asset | Activity (documentation)1:1 | Fully supported | |
| Form | Form (documentation)1:1 | Fully supported | |
| Lead Scoring Model | Lead Scoring Model (documentation)1:1 | Fully supported | |
| Picklist | Picklist (configuration)lossy | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
Oracle Eloqua gotchas
Contact-based pricing model inflates migration scope
No native export or migration tooling in Eloqua
Bulk API soft limits throttle large data transfers
5 GB import file size cap complicates bulk data loads
SOAP API deprecated; REST/Bulk APIs require endpoint caching
Twenty CRM gotchas
Import order is enforced and critical
Export limited to 20,000 records and visible columns only
Soft-deleted records count toward uniqueness and trigger restores
API rate limits cap at 200 req/min on Organization tier
No native email sequences — follow-up cadences require external tools
Pair-specific challenges
Migration approach
Discovery and data audit
We audit the Eloqua environment across all objects: contact volume, account volume, CDO count and schema, activity record volume by type (email, form, page visit, campaign response), campaign count, segment and list membership, and lead scoring model structure. We also identify any third-party integrations that route data through Eloqua, as those connection points will need to be re-established with Twenty CRM. The discovery output is a written data inventory with record counts per object, field-level schema for each CDO, and a preliminary object mapping plan.
Destination schema design and field mapping
We design the Twenty CRM destination schema based on the discovered Eloqua data model. This includes creating custom fields on Contact, Company, and Activity objects for Eloqua-specific data that has no direct Twenty CRM equivalent. We define the field mapping between Eloqua contact fields and Twenty CRM contact fields, resolve the Account-to-Company parent lookup, and design extension tables for CDOs that exceed the custom field threshold. The mapping document is reviewed by the customer's admin before any extraction begins.
Sandbox extraction and reconciliation
We run an initial extraction from Eloqua into a staging environment using a representative data sample (typically 5-10% of total record volume). This validates the Bulk API extraction logic, confirms field-level data quality, identifies any picklist value mismatches, and produces a reconciliation report showing what Eloqua exported versus what arrived in Twenty CRM. Corrections to the field mapping, data transformation rules, and chunking strategy happen at this stage before production extraction begins.
Bulk API extraction with rate-limit compliance
We extract Eloqua data in dependency order: Accounts first (for Company creation in Twenty CRM), then Contacts (with AccountId resolved to the parent Company), then CDO records (with parent lookups resolved), then Activity records (with ContactId resolved for each engagement event), then segment and list membership (as tags on Contact records). Each extraction job uses Eloqua's Bulk API 2.0 with chunking to stay under the 5 GB file cap and sequential job scheduling to respect rate limits. Activity records spanning multiple years are split by year to prevent single-job timeout.
Production import and validation
We import into Twenty CRM in the same dependency order used for extraction. Each phase (Companies, Contacts, CDOs, Activities, Tags) emits a row-count reconciliation report showing inserted records, updated records, and errors. We validate a random sample of 25-50 records per phase against the Eloqua source to confirm field-level accuracy. Any records that fail validation (missing required fields, lookup resolution errors, picklist mismatches) are corrected in the staging environment and re-imported before the next phase begins.
Cutover, campaign rebuild handoff, and documentation delivery
We coordinate a cutover window during which no new records are created in Eloqua. A final delta extraction captures any records modified during the migration window. After cutover, we deliver the campaign and automation rebuild guide: campaign metadata, scoring model specification, segment filter definitions, and form field configurations organized by the Eloqua object they belong to. This document is the handoff artifact that the customer's marketing ops team uses to reconstruct automation logic in their chosen replacement platform. We do not rebuild campaigns or scoring models as a standard migration scope.
Platform deep dives
Oracle Eloqua
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 1 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Oracle Eloqua and Twenty CRM.
Object compatibility
1 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
Oracle Eloqua: Bulk API: 2,000 records/hour per sync type; REST API: 10-20 concurrent requests depending on tier.
Data volume sensitivity
Oracle Eloqua exposes a bulk API — large-volume migrations stream efficiently.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during Oracle Eloqua to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Oracle Eloqua to Twenty CRM migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave Oracle Eloqua
Other ways to arrive at Twenty CRM
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.