GITNUXSOFTWARE ADVICE
Top 10 Best List Of CRM Software of 2026
Ranking roundup for a list of crm software, comparing Copper, Keap, and NetHunt CRM for sales teams and technical buyers.
How we ranked these tools
Core product claims cross-referenced against official documentation, changelogs, and independent technical reviews.
Analyzed video reviews and hundreds of written evaluations to capture real-world user experiences with each tool.
AI persona simulations modeled how different user types would experience each tool across common use cases and workflows.
Final rankings reviewed and approved by our editorial team with authority to override AI-generated scores based on domain expertise.
Score: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
Copper is the best pick for sales teams that want Google Workspace-centric CRM with deep API-driven automation and tightly controlled workflows, whereas Keap fits mid-size teams that need structured CRM objects and end-to-end lead-to-action automation.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Copper
Email and calendar activity synchronization that writes touchpoints into Copper tasks and CRM objects.
Built for fits when sales teams need CRM integration depth with API-driven provisioning and controlled automation..
Keap
Editor pickBuilt-in automation sequences that trigger on CRM events and update contact and deal fields.
Built for fits when mid-size teams need workflow automation with structured CRM objects and an API for integrations..
NetHunt CRM
Editor pickEmail activity timeline that stays attached to CRM entities and drives automation triggers through API-accessible events.
Built for fits when sales teams run outreach through Gmail or Outlook and need automation with an API..
Related reading
Comparison Table
This comparison table evaluates CRM tools such as Copper, Keap, NetHunt CRM, Zendesk Sell, and Insightly across integration depth, data model design, automation capabilities, and API surface. It also highlights admin and governance controls like RBAC, provisioning workflows, and audit log coverage so teams can assess fit for their schema and automation requirements. Readers can use the results to compare extensibility options and configuration choices that affect throughput and support for custom integrations.
Copper
SMBGoogle Workspace-centric CRM for relationship management, deal tracking, and sales automation.
Email and calendar activity synchronization that writes touchpoints into Copper tasks and CRM objects.
Copper is a CRM built around a structured entity model for contacts, companies, deals, and activities, with field-level organization that reduces drift across integrated systems. Integration depth is strongest where email, calendar, and sales workflows can map into activities and pipeline stages, then flow back into reporting objects. The API and automation surface support extensibility through record create and update operations, webhook-style event handling, and consistent identifiers for syncing.
A tradeoff appears with high customization demands, because complex schema changes and deep automation logic still require careful configuration and disciplined data mapping. Copper fits teams that need controlled data provisioning and repeatable workflow automation tied to sales touchpoints, not teams that only require spreadsheet-like CRM usage. Operational governance matters when multiple users update the same contact and deal records, because RBAC and audit-oriented controls limit unintended changes.
- +Activity-first data mapping ties emails and meetings to CRM records
- +API supports programmatic provisioning and consistent record syncing
- +Automation converts events into tasks, status changes, and pipeline updates
- +RBAC and governance controls reduce cross-user data overwrite
- –Complex schema modifications require careful field mapping discipline
- –Advanced automation logic can increase admin workload for edge cases
- –Throughput during large backfills depends on configured sync strategy
- –Reporting customization may require extra configuration beyond core fields
Sales operations teams
Automate pipeline stages from activity signals
Fewer manual stage updates
RevOps engineering
Provision leads into Copper via API
Controlled lead onboarding
Show 2 more scenarios
Customer success teams
Track onboarding activities in CRM
More consistent follow-through
Activity records tie onboarding touchpoints to contacts and accounts for follow-up scheduling.
Sales team leads
Govern updates with RBAC
Lower data inconsistency
Role-based permissions limit who can edit pipeline and contact fields across workflows.
Best for: Fits when sales teams need CRM integration depth with API-driven provisioning and controlled automation.
More related reading
Keap
SMBCRM and sales automation platform for small businesses with lead capture, email, and invoicing support.
Built-in automation sequences that trigger on CRM events and update contact and deal fields.
Keap fits teams that need CRM records tied to customer journeys, not just pipelines. Integration depth shows up through native connectors for common business systems and the ability to move leads from web forms into structured contact objects. Automation and API surface align around triggers, conditions, and field updates, which reduces custom scripting for common nurture and follow-up workflows. The data model is practical for sales and marketing motions, using fields and custom attributes to shape records and segmentation.
A key tradeoff appears in governance and extensibility boundaries for highly customized data schemas. Keap workflows can reach many CRM fields, but complex modeling and cross-object transformations can require careful configuration and may not match the flexibility of pure custom-code stacks. Keap works best when teams can standardize on its contact and deal objects, then use automation rules to enforce process consistency. It is also a fit when auditability and role-based access matter for operators who routinely adjust sequences and routing logic.
- +Automation sequences tied to contact fields and tags
- +API supports programmatic sync of CRM records and activities
- +Native form capture maps leads into CRM objects
- +Workflow configuration supports repeatable routing and follow-up
- –Advanced schema modeling beyond core objects can be limiting
- –Cross-system data mapping can require ongoing configuration
- –Complex governance for large orgs may need stronger controls
- –Throughput-heavy integrations can strain workflow-driven processing
Sales and marketing ops teams
Automate follow-up after lead capture
Consistent response and pipeline hygiene
RevOps integration teams
Sync CRM with external systems
Fewer manual data reconciliation cycles
Show 2 more scenarios
Customer success coordinators
Coordinate lifecycle tasks per segment
Lower missed handoffs
Automation rules assign next actions based on contact attributes and history.
Small multi-role teams
Standardize routing without custom code
Repeatable process across reps
Configured workflows enforce lead handling and communications tied to CRM records.
Best for: Fits when mid-size teams need workflow automation with structured CRM objects and an API for integrations.
NetHunt CRM
SMBGmail-native CRM for sales pipelines, records, email campaigns, and workflow automation.
Email activity timeline that stays attached to CRM entities and drives automation triggers through API-accessible events.
NetHunt CRM maps CRM entities to an activity timeline built around email, so outreach history can remain queryable per contact and deal. The data model connects contacts, companies, deals, and tasks through fields and activities, which supports automation rules that trigger on those changes. Integration depth is strongest where email systems are the source of truth, because syncing and activity ingestion keep context attached to CRM records.
A tradeoff appears when teams need multi-system data normalization beyond email-centric schema, since complex cross-CRM hierarchies require careful field mapping and automation configuration. NetHunt CRM fits best when a sales team wants automation that reacts to communication events and records outcomes without building custom middleware.
- +Email-first data model links activities to contacts and deals
- +Automation triggers on CRM field and pipeline changes
- +API and webhooks support external workflow integration
- +Role-based access controls and user-level audit visibility
- –Non-email source systems need extra mapping for clean schema alignment
- –Advanced automation can increase configuration overhead over time
Sales operations teams
Automate follow-ups per deal stage
Fewer missed follow-ups
RevOps integration engineers
Sync leads into external systems
Consistent event propagation
Show 2 more scenarios
Customer-facing support leads
Track customer communications in CRM
Clear communication audit trail
Store email activity on contact records to keep case context connected to deal history.
Mid-market sales managers
Govern access across teams
Controlled data governance
Apply RBAC to limit edits while reviewing user actions via CRM audit visibility.
Best for: Fits when sales teams run outreach through Gmail or Outlook and need automation with an API.
Zendesk Sell
SMBSales CRM for lead and deal management with native alignment to Zendesk support workflows.
Stage-based automation that creates tasks and updates deal fields tied to the pipeline workflow.
Zendesk Sell fits CRM users who need tight linkage between pipeline work and support context. It provides contact and deal objects with activity history tied to communications, so sales reps can work from shared customer timelines.
Workflow automation supports trigger-based actions like task creation and status updates tied to deal stages. API access and configuration options cover integration and extensibility needs across email, meeting logging, and custom business processes.
- +Deal stages can drive automated tasks and follow-ups
- +Activity timeline connects sales actions to customer history
- +API supports custom fields, objects, and external workflow wiring
- +Role-based access control reduces exposure across teams
- –Data model customization can require schema planning across teams
- –Automation complexity increases with multi-step rules and many triggers
- –Field-level reporting coverage can lag behind custom workflow depth
- –Admin governance across integrations needs careful configuration
Best for: Fits when sales teams need deal automation tied to shared customer activity and dependable API integration.
Insightly
SMBCRM platform with relationship management, pipeline tracking, workflow automation, and project linkage.
Workflow automation using triggers on CRM events paired with an API for bidirectional system sync.
Insightly tracks leads, contacts, and opportunities with CRM records linked to projects and tasks. The data model ties contacts to activities, relationships, and custom fields, which supports schema-driven reporting and consistent object usage.
Insightly’s integration depth comes from its API and webhooks, plus workflow automation that can push changes across CRM objects. Admin and governance controls focus on user permissions, audit visibility for key actions, and structured customization through fields and workflows.
- +REST API with object CRUD and query patterns for CRM data sync
- +Workflow automation triggers on record changes across CRM modules
- +Custom fields and schema consistency across leads, contacts, and opportunities
- +Webhooks for outbound event delivery into external systems
- –Automation complexity grows quickly with multi-step conditional routing
- –Some reporting requires careful field mapping across custom schemas
- –Data model extensibility depends on field types and module boundaries
- –API surface covers core objects, but edge cases need more custom logic
Best for: Fits when sales teams need CRM automation and integration control without heavy admin overhead.
Close
SMBSales CRM built for inside sales teams with calling, email sequences, and pipeline management.
Conversation logging with call outcome fields that roll into pipeline metrics and activity histories.
Close is a sales-focused CRM that centers records around conversations and call outcomes. Its data model ties leads, contacts, and deals to activities like calls and tasks, so reporting stays grounded in interaction history.
Close supports integration with phone, email, and workflow tooling, and it exposes an API surface for custom sync and automation. Admin controls focus on user permissions and operational auditability around access and changes.
- +Conversation-first data model ties activities to contacts and deals
- +API supports custom lead, activity, and deal syncing for integrations
- +Automation features cover workflow steps tied to tasks and pipeline stages
- +Role-based access controls control who can view and change records
- –Schema customization is limited compared with CRMs that offer deeper custom entities
- –Automation needs careful mapping to avoid mismatches across integrated systems
- –Reporting granularity can lag behind CRMs with more configurable analytics objects
- –Admin governance for integrations requires more setup than simple UI-only setups
Best for: Fits when sales teams need conversation-linked CRM data with API-backed automation and clear RBAC.
Nimble
SMBRelationship-focused CRM that unifies contacts, email history, and social profile data.
Unified contact record with activity-driven workflow automation and an API for custom data sync.
Nimble focuses on contact-centric CRM data captured from multiple sources and kept in a consistent contact record model. It supports workflow automation that moves leads through stages and triggers follow-ups based on rules tied to contact and activity data.
Integration depth and extensibility depend on its connected apps and API surface for custom data sync, enrichment, and operational automation. Admin governance centers on user permissions and activity visibility so teams can control access to CRM objects and review changes.
- +Contact-first data model reduces fragmentation across sources
- +Workflow rules trigger tasks from activity and lead stage changes
- +API supports custom integrations for sync and automation
- +Permission controls limit CRM access by user role
- –Extensibility requires technical work for custom schema mapping
- –Automation throughput depends on rule design and event volume
- –Complex reporting needs careful configuration of data fields
- –Governance relies on user setup for consistent change tracking
Best for: Fits when teams need contact-centric CRM with automation rules and an API for custom integrations.
Less Annoying CRM
SMBSimple CRM for contact management, pipelines, tasks, and team collaboration.
Pipeline stage rules that generate tasks and update deal state through configurable automation conditions.
Less Annoying CRM focuses on configurable sales workflows with an explicit data model for contacts, companies, deals, and activities. It supports integration via documented exports and API endpoints for records and events, which matters for schema mapping and automation.
Automation covers pipeline stages and tasking based on trigger conditions, with rule configuration that is easier to audit than custom scripts. Admin controls emphasize role-based access and consistent record permissions for teams that need governance around who can update what.
- +Clear CRM data model for contacts, companies, deals, and activities
- +Workflow automation rules trigger tasks from pipeline and record changes
- +API supports record access for automation and integration programming
- +Role-based access controls separate edit permissions by user role
- –Integration depth is limited compared with enterprise CRM ecosystems
- –API surface is narrower, which reduces automation extensibility
- –Admin and governance tooling lacks detailed audit log visibility
- –Configuration for complex branching workflows can feel constrained
Best for: Fits when small teams need pipeline automation and an API for internal integrations without heavy governance overhead.
Capsule
SMBCRM for contacts, sales pipelines, tasks, and lightweight workflow management.
Capsule API plus webhooks for provisioning, synchronization, and workflow triggers across external systems
Capsule records contacts, organizations, deals, and activities in a shared CRM workspace while focusing on a clean data model for relationship tracking. It supports automation such as task creation from workflows and maintains an extensible surface through documented APIs and webhooks.
Integrations connect email and calendars to activity history and sync key fields across systems. Admin governance is centered on user roles and audit visibility for key record changes rather than deep schema-level control.
- +Clear CRM data model for contacts, companies, deals, and activities
- +API and webhooks support external automation and bidirectional sync
- +Workflow automation can create tasks based on CRM events
- +Email and calendar integrations map messages to activity history
- –Limited admin governance for schema customization and field-level rules
- –Automation depth depends on preset workflows rather than full conditional logic
- –RBAC coverage is usable but not granular enough for complex orgs
- –API throughput and rate limits can constrain high-volume sync jobs
Best for: Fits when sales and support teams need relationship CRM with dependable email sync and API-driven automation.
Pipeline CRM
SMBSales CRM for contact management, pipeline visibility, and activity tracking.
State-triggered workflow automation mapped to pipeline stages and record fields through its API surface.
Pipeline CRM targets sales teams that need a controlled deal pipeline with automation and strong schema discipline. Core capabilities include pipeline stages, deal and contact records, tasking, and workflow rules tied to state changes.
Integration depth hinges on its API and webhook-style extensibility, which matters when provisioning objects and syncing events across systems. Admin governance depends on role-based access controls and auditable changes so schema updates and automation edits do not run unchecked.
- +Pipeline-first data model ties automation rules to stage changes
- +API supports programmatic provisioning and event-driven integrations
- +Workflow automation reduces manual task and status updates
- +RBAC helps restrict access to records and configuration
- –Complex reporting requires careful schema mapping and filters
- –Automation logic can be harder to version without a sandbox flow
- –Admin controls feel granular but are not as centralized as some CRMs
- –Multi-system data sync needs explicit conflict handling
Best for: Fits when sales ops teams need pipeline-centric automation with an API and governance controls.
How to Choose the Right list of crm software
This buyer’s guide covers Copper, Keap, NetHunt CRM, Zendesk Sell, Insightly, Close, Nimble, Less Annoying CRM, Capsule, and Pipeline CRM. It focuses on integration depth, the CRM data model, automation and API surface, and admin and governance controls.
Each section translates real capabilities and constraints into selection criteria for teams building CRM-backed workflows and external sync. It also calls out recurring schema mapping and automation configuration pitfalls seen across these tools.
List of CRM software that supports integration-first records, automation triggers, and governed access
List of CRM software here refers to CRM products where contact, lead, deal, and activity records can be provisioned and synchronized through an API or webhooks. It also covers automation that writes back into the CRM data model when events happen in email, meetings, calls, pipeline stages, or record updates.
This software category solves operational problems like inconsistent field mapping across systems, lack of controlled task creation, and weak governance when multiple users and integrations modify the same records. In practice, Copper routes email and calendar touchpoints into CRM tasks and objects through documented integrations and an API-backed data model, while Zendesk Sell ties deal stages to task automation tied to shared customer timelines.
Evaluation criteria for governed CRM data models and automation through API and webhooks
Integration depth determines whether the CRM can ingest and write structured activity data like email, meeting logs, and call outcomes without manual re-keying. Data model fit determines whether fields, objects, and relationships map cleanly across leads, contacts, deals, and activities.
Automation and API surface determine whether workflows can be versioned through configuration and driven by record or event triggers. Admin and governance controls determine whether role-based access, audit visibility, and change oversight prevent cross-user overwrites and unsafe automation edits.
Schema-aware API and programmatic provisioning for CRM records
Copper provides an API surface designed for schema-aware record operations, which supports consistent provisioning and record syncing into external systems. Insightly also emphasizes REST API patterns with object CRUD and query patterns for bidirectional sync across CRM modules.
Activity and timeline mapping into CRM objects and tasks
Copper’s email and calendar activity synchronization writes touchpoints into Copper tasks and CRM objects, keeping pipeline work grounded in real interactions. NetHunt CRM keeps an email activity timeline attached to CRM entities and uses API-accessible events to drive automation triggers.
Automation triggers that update pipeline state and create tasks
Zendesk Sell uses stage-based automation to create tasks and update deal fields tied to the pipeline workflow. Less Annoying CRM uses pipeline stage rules to generate tasks and update deal state through configurable automation conditions.
Event-driven integration surface with webhooks for outbound workflow wiring
Capsule supports a documented API plus webhooks for provisioning, synchronization, and workflow triggers across external systems. Insightly adds webhooks for outbound event delivery so external systems can react to CRM record changes.
Workflow automation sequences tied to CRM fields, tags, and events
Keap focuses on configurable automation sequences that trigger on CRM events and update contact and deal fields. Nimble also runs activity-driven workflow automation where rules trigger tasks based on contact and lead stage changes.
Admin governance with RBAC and audit visibility for operational change
Copper includes role-based access controls and governance-oriented operational controls for collaboration and data handling. Close and Capsule both center admin controls on user permissions and operational audit visibility for key record changes.
Pick a CRM tool that matches the event source, data schema, and governance model
Selection should start with which event sources must flow into the CRM data model. Teams running outreach through Gmail or Outlook usually align with NetHunt CRM because its email activity timeline drives automation through API-accessible events.
Next, the CRM data model must match the objects that need to be synchronized. Copper’s activity-first mapping can reduce reconciliation work when email and calendar touchpoints must become tasks and object updates, while Close centers conversation logging tied to call outcomes for pipeline metrics and activity histories.
Match the CRM data model to the event sources that feed the workflow
If the workflow starts from email and calendar touchpoints, Copper and NetHunt CRM provide event-to-task mapping that writes activity into CRM objects. If the workflow starts from deal stages, Zendesk Sell and Less Annoying CRM tie automation directly to stage transitions and deal field updates.
Validate the automation trigger types needed for the process
Keap’s automation sequences trigger on CRM events and update contact and deal fields, which fits structured field-driven routing and follow-up. Nimble and Insightly also rely on workflow automation triggers on record or activity changes, but complex multi-step routing increases configuration overhead.
Check the API and webhook surface for both directions of sync
For bidirectional sync and programmatic provisioning, Copper and Insightly emphasize API operations and query patterns for CRM data sync. For outbound event delivery into external systems, Insightly webhooks and Capsule webhooks support event-driven integration.
Confirm how schema changes and field mapping are handled before scaling
Copper can require careful field mapping discipline for complex schema modifications, so schema governance must include change procedures and mapping standards. Pipeline CRM focuses on pipeline-first state triggers and depends on explicit conflict handling for multi-system data sync.
Require governance controls that align with multi-user and integration risks
Where multiple teams and integrations modify records, Copper’s RBAC plus governance controls reduce cross-user overwrite risk. Close and Capsule provide RBAC and audit visibility for key record changes, which supports operational accountability during integration changes.
Which teams should pick each CRM tool based on automation, integration, and governance fit
Different tools in this set prioritize different mechanics, like email-to-task mapping, stage-triggered automation, or conversation-first reporting. The best fit depends on which records must be synchronized and which system becomes the workflow event source.
Teams also need to align governance controls with how many users and integrations will write to the same CRM fields and objects.
Sales teams that need email and calendar touchpoints to become governed CRM tasks
Copper is a fit because its email and calendar synchronization writes touchpoints into Copper tasks and CRM objects, and its API supports schema-aware record operations for controlled provisioning. Nimble is also a fit when the team wants activity-driven workflow automation tied to a unified contact record.
Teams running outreach in Gmail or Outlook and requiring API-accessible event triggers
NetHunt CRM fits because its email activity timeline stays attached to CRM entities and drives automation triggers through API-accessible events. Capsule fits sales and support teams needing dependable email and calendar integration with an API plus webhooks for workflow triggers.
Sales operations teams that need pipeline stage automation with strong state control
Zendesk Sell fits teams that want stage-based automation that creates tasks and updates deal fields tied to the pipeline workflow. Pipeline CRM fits teams prioritizing pipeline-centric automation mapped to pipeline stages and record fields through its API surface.
Mid-size teams that want configurable workflow sequences tied to CRM fields and tags
Keap is a fit because it turns workflows into configurable sequences that trigger on CRM events and update contact and deal fields. Insightly is also a fit when the team wants workflow automation tied to CRM record changes paired with REST API sync and webhooks.
Small teams that need pipeline automation and an API for internal integrations with simpler governance
Less Annoying CRM fits teams that want pipeline stage rules that generate tasks and update deal state through configurable automation conditions. Close fits teams focused on conversation logging where call outcomes roll into pipeline metrics and activity histories with RBAC and audit-oriented operational controls.
CRM selection pitfalls that break automation and integration at scale
Common failures come from mismatched schema planning, automation complexity that outgrows configuration, and weak governance for integration-driven writes. These pitfalls appear across tools that support rich triggers and extensibility.
Fixes focus on schema discipline, explicit trigger design, and governance checks before expanding event volume or adding new integration writers.
Choosing a CRM for the UI workflows without validating API-driven provisioning and sync direction
A pipeline built around manual steps can collapse when record creation must happen programmatically, which is why Copper and Insightly both emphasize API surface for record operations. If outbound integration is required, Capsule and Insightly webhooks must be verified early because event delivery and provisioning need two-way mechanics.
Underestimating schema mapping work when custom fields and objects become core to routing
Copper’s complex schema modifications can require careful field mapping discipline, and Zendesk Sell’s data model customization needs schema planning across teams. Keap’s advanced schema modeling beyond core objects can become limiting, so field and tag strategies should be tested against the expected routing rules.
Building multi-step automation logic without controlling trigger scope and throughput
Insightly automation complexity can grow quickly with multi-step conditional routing, and NetHunt CRM’s advanced automation can increase configuration overhead over time. Pipeline CRM requires explicit conflict handling for multi-system data sync, so automation trigger design must account for write collisions.
Assuming automation governance is automatic across multiple integrations and user roles
Less Annoying CRM provides role-based access but lacks detailed audit log visibility for schema-level change oversight, which can complicate troubleshooting. Copper’s RBAC and governance controls help reduce cross-user overwrite risk, so governance requirements should match the number of record writers.
How We Selected and Ranked These Tools
We evaluated Copper, Keap, NetHunt CRM, Zendesk Sell, Insightly, Close, Nimble, Less Annoying CRM, Capsule, and Pipeline CRM using three criteria: features, ease of use, and value. Features carried the most weight in the overall rating, while ease of use and value each contributed the rest in equal share. This editorial approach used the stated capabilities and constraints for integration depth, data model fit, automation and API surface, and admin governance controls.
Copper separated itself from lower-ranked tools because it couples email and calendar activity synchronization with task and CRM object writes, plus an API surface built for schema-aware record operations and controlled provisioning. That combination lifts integration depth and automation control through programmable record updates, which is why Copper ranks highest overall.
Frequently Asked Questions About list of crm software
Which CRM in the list exposes the most API-first data model for schema-aware record operations?
How do the CRMs handle workflow automation that writes into CRM fields or pipeline stages?
Which option best matches a Gmail or Outlook outreach workflow that stays attached to CRM records?
What CRM fits when sales needs deal automation tied to shared support or customer communication context?
Which CRM is most suitable for conversation-based selling where call outcomes drive pipeline metrics?
How do admin controls and RBAC show up across the list for controlling who can change records and automation?
Which CRMs support extensibility through webhooks and event triggers for internal system syncing?
What tool is the best fit for managing relationships across contacts, organizations, deals, and tasks without heavy schema administration?
How can teams migrate existing CRM data into these tools while keeping fields and schemas consistent?
Conclusion
After evaluating 10 tools, Copper stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→Need a personal recommendation?
Software Advisory Service
Skip months of vendor evaluation. Our analysts recommend the right tool for your business in 2–4 weeks.
Talk to an analyst →