Segment API: Complete 2026 Review

The question behind every CDP API integration is whether the programmatic surface matches what you need to build. Not just whether the endpoints exist, but whether the authentication model, the rate limits, the SDK coverage, and the pricing let you ship and scale without hitting a wall three months in.

Segment's API is not one surface but several.

The Tracking API ingests events from web, mobile, and server sources. The Public API manages workspace resources (sources, destinations, tracking plans, audiences, functions) programmatically. The Profile API queries identity-resolved customer profiles in real time.

Source SDKs cover 10+ languages and platforms, and the interactive reference at docs.segmentapis.com is OpenAPI-based with per-endpoint versioning. For a platform built from an open-source JavaScript library, that API surface is deliberate.

But breadth of surface and depth of data are different things.

Segment's API collects, routes, and unifies first-party behavioral data: page views, screen events, track calls, identify calls, and the traits and audiences computed from them. If you need to instrument a data pipeline, manage its infrastructure as code, and query identity-resolved profiles, the API is scoped for that job.

What it does not provide is the B2B intelligence layer: contact enrichment, company attributes, org charts, technographics, buyer intent signals, or direct-dial phone numbers. That is a different data domain, and Segment's API was never designed to cover it.

This is where ZoomInfo, the AI GTM platform, enters the picture.

Its Enterprise API is a REST suite covering search, enrichment, AI intelligence, and audience management across 500M contacts and 100M companies, with OAuth 2.0 authentication and an MCP server for AI-agent workflows. The two APIs are layers of the same data stack, not rivals: Segment handles the behavioral pipeline, ZoomInfo provides the business intelligence that enriches it.

This review covers the Segment API in full technical depth first (authentication, endpoints, webhooks, SDKs, rate limits, and pricing), then reviews ZoomInfo's API as the B2B intelligence layer that picks up where customer data collection stops.

Segment API at a Glance

Segment API: What Works Well & What to Plan Around

Segment API: Authentication & Getting Started

Segment's API surfaces use different authentication mechanisms depending on which surface you call.

Tracking API (Event Ingestion)

Every Segment source has a Write Key that authenticates inbound data.

Source: Segment

The Tracking API at api.segment.io/v1 accepts JSON payloads authenticated via the Write Key passed as a Basic Auth username (with an empty password), or via OAuth 2.0 for destination connections that need token lifecycle management. Regional endpoints exist for EU compliance at eu1.api.segmentapis.com.

Getting started is immediate: create a free account, add a source, copy the Write Key, and send your first event. No approval process, no enterprise gate. A basic authenticated call looks like this:

curl -X POST "https://api.segment.io/v1/track" \

-u YOUR_WRITE_KEY: \

-H "Content-Type: application/json" \

-d '{"userId": "user_123", "event": "Item Purchased", "properties": {"price": 49.99}}'

The Tracking API accepts six call types defined in the Segment Spec: identify (who the user is), track (what they did), page (web page views), screen (mobile screen views), group (account association), and alias (identity merging). Each event can carry up to 10,000 properties before additional properties are silently dropped.

Public API (Workspace Management)

The Public API uses bearer token authentication.

Tokens are generated inside the Segment workspace under Access Management settings, scoped to the workspace and aligned to Segment's IAM role-based permissions. Each token is workspace-scoped and cannot access resources in other workspaces.

Two security details worth knowing:

• Segment scans public repositories for exposed tokens and automatically revokes them.

• The Public API is not available on the free tier. It ships at no extra charge on the Customer Data Pipeline plan (Team and Business tiers) and the Customer Data Platform plan.

The legacy Config API uses Basic Auth with the personal access token as both username and password. It covers the same core resources as the Public API but relies on slugs rather than unique IDs and will not receive future enhancements. Segment recommends migrating to the Public API.

Segment API: Core Endpoints & Capabilities

The API surface divides into three areas: event ingestion (Tracking API), workspace management (Public API), and real-time profile queries (Profile API). Each serves a different integration pattern.

Tracking API: Event Ingestion

The Tracking API is the event collection surface that source SDKs abstract.

Events follow the Segment Spec, a standardized taxonomy covering common business events (ecommerce, B2B SaaS, video, mobile). Once an event reaches Segment's servers, schema controls and tracking plans filter and validate it, then eligible events fan out to all enabled destinations.

Events flow through two connection modes:

• Cloud mode: Segment's servers forward data server-side to the destination. The default path for most integrations.

• Device mode: The destination's SDK loads directly in the browser or app, sending data to both Segment and the destination simultaneously. Required by some destinations that need client-side access.

The Destination Actions framework governs how events map to destination-specific actions, with control over triggers, field-level mapping (including coalesce, case, JSON, flatten, replace, and concatenate transformations), and required vs. optional fields.

Source: Segment

What you would build with this: a single event instrumentation layer that captures user behavior from your web app, mobile app, and backend services through one API, then routes that data to your analytics platform, CRM, ad networks, and data warehouse simultaneously, without maintaining separate tracking code for each tool.

Public API: Workspace Management

The Public API covers programmatic management of the full Segment workspace. All resources support standard GET/POST/PATCH/DELETE operations with JSON payloads and cursor-based pagination.

The resource areas include:

Data Pipeline Management:

• Sources: create, read, update, delete; list sources; create and revoke Write Keys; read and update schema settings; manage labels; list connected destinations and warehouses

• Destinations: create, read, update, delete; manage subscriptions; create and manage destination filters; retrieve event delivery metrics

• Warehouses: create, read, update, delete; validate connections; list connected sources; check connection state

• Reverse ETL: create, read, update, delete models; trigger and cancel manual syncs; query sync status

Data Governance:

• Tracking Plans: create, read, update, delete; connect and disconnect sources for violation monitoring

• Deletion and Suppression: create source and workspace regulations (GDPR/CCPA delete and suppress); list regulations and suppressions

Activation and Engagement:

• Audiences (Engage): create, read, update, delete; manage schedules and activations; link and unlink destinations; run audience previews; force-execute audience runs

• Spaces (Engage): list spaces; batch query and replace messaging subscriptions

• Profiles Sync: create profiles warehouses; manage selective syncs

Extensibility:

• Functions: create, read, update, delete source functions, destination functions, and insert functions; manage deployments and version history; restore versions

• dbt: trigger dbt model syncs

Administration:

• IAM: manage workspace users, roles, and group labels

What you would build with this: a CI/CD pipeline that provisions Segment sources and destinations as infrastructure-as-code, a multi-tenant SaaS platform that creates isolated Segment sources per customer, or an internal tool that monitors event delivery health and tracking plan violations across your organization.

Profile API: Real-Time Profile Queries

The Profile API queries Segment's identity-resolved profiles.

Source: Segment

You can retrieve any unified profile by any identifier (email, user ID, anonymous ID, custom external ID) with response times under 200ms, returning traits, audience memberships, and full event history in real time.

The Profile API requires the Unify add-on, available on the Business tier and a prerequisite for Twilio Engage.

What you would build with this: a real-time personalization layer that queries a customer's unified profile at page load to customize the experience, or a support tool integration that pulls the full customer timeline into a Zendesk or Salesforce sidebar.

Functions: The Extensibility Surface

Functions extend every part of the pipeline with custom JavaScript running on managed AWS Lambda:

• Source Functions: ingest data from any webhook or API not covered by a native source

• Destination Functions: send data to any endpoint not covered by a native destination

• Destination Insert Functions: transform data in-flight between Segment and a destination

Source: Segment

A Functions Copilot generates function code using AI, which helps teams that need custom integrations without JavaScript expertise. Functions are billed by execution time.

Segment API: Webhooks & Events

Segment does not publish a traditional inbound webhook endpoint.

Instead, it provides two outbound webhook destinations that push Segment events to external URLs, plus Source Functions for inbound webhook reception.

Outbound: Extensible Webhook Destination

The Extensible Webhook destination is the current, recommended option. It supports all five Segment event types (Page, Alias, Group, Identify, Track) and offers:

• Configurable authentication: no auth, Bearer token, or OAuth 2.0 (authorization-code or client-credentials flow, with automatic token refresh on 401)

• Custom payload mapping and field selection

• Multiple HTTP methods (POST, PATCH, PUT)

• Configurable batch sizes

• Optional insert functions for in-flight payload transformation

• Engage integration for audience-triggered webhook delivery

Integration recipes exist for Amazon Ads Audience Sync, Google Search Ads 360, Microsoft Dynamics 365, and Reddit Ads.

An older Webhooks (Actions) destination is also available in the standard catalog.

Two things to plan around:

• Segment supports batching entire payloads to webhook endpoints but does not support batching individual objects within a payload.

• Neither webhook destination publishes retry counts or delivery-guarantee SLAs.

Inbound: Source Functions

Source Functions provide the inbound webhook capability. They are JavaScript functions hosted on Segment that receive webhooks from external systems and translate them into Segment events.

Source: Segment

This gives Segment an inbound webhook surface for any system not covered by a native cloud source, but it requires writing and maintaining the translation code.

Segment API: SDKs, Docs & Rate Limits

SDKs & Libraries

Segment publishes two categories of official SDKs, all maintained by Segment/Twilio and hosted on GitHub under the segmentio organization.

Source SDKs (for sending events into Segment):

• Web: JavaScript (analytics.js / @segment/analytics-next)

• Mobile: Swift/Apple, Kotlin (Android), React Native, Flutter (Beta), Unity, Xamarin

• Server: .NET, Clojure, Go, Java, Kotlin, Node.js, PHP, Python, Ruby

• HTTP API: direct REST calls for any language not covered by an official SDK

• Pixel Tracking API: server-side pixel for environments where JavaScript cannot run

That is broad coverage. The source SDKs abstract the Tracking API's event ingestion, standardizing calls across platforms and handling batching, retries, and queue management.

Public API management SDKs:

Official SDKs for workspace management in JavaScript, TypeScript, Go, Java, Swift, and C#. The legacy Config API has no official language clients, though the reference docs include example code in cURL, Go, Node, and Python.

Documentation & Developer Experience

Segment's documentation splits across two portals, each serving a different audience.

Platform documentation at segment.com/docs covers the full product surface: getting-started guides, source and destination catalogs, Unify, Engage, Protocols, privacy, and usage/billing references.

The docs include role-specific introduction guides for developers, data users, and workspace admins. How-to guides cover multi-channel re-engagement, LTV forecasting with SQL, attribution, and migration from other analytics tools. Documentation pages offer "View as Markdown" and "Copy as Markdown" functions, useful for teams referencing docs programmatically.

Public API reference at docs.segmentapis.com is OpenAPI-based with inline request/response examples, code snippets in multiple languages, and a live "Try It!" explorer for testing calls in the browser.

The reference supports per-endpoint versioning: stable, beta, and alpha versions coexist, and breaking changes are versioned rather than applied in-place. A product changelog tracks Segment-specific updates.

Supplementary learning resources include Segment Academy and Segment University with video walkthroughs.

Developer support channels: Twilio Help Center, friends@segment.com for API-specific questions, and the Stack Overflow segment tag. No dedicated developer Slack or community forum is referenced in the docs.

The documentation is good. Coverage runs from ecommerce event specs to Databricks Reverse ETL setup to AWS PrivateLink configuration, and the interactive Public API reference is the fastest way to confirm a response shape without writing code.

Rate Limits & Constraints

Segment publishes rate limits for event ingestion but keeps Public API limits less transparent.

Tracking API (event ingestion):

• 1,000 events per second per workspace. Segment reserves the right to queue events above this threshold. A higher limit can be requested by contacting Segment (friends@segment.com).

• 10,000 properties per individual event. Properties beyond this limit are silently dropped.

• Engage inbound data: 1,000 events per second, a separate limit for Engage-ingested events.

Outbound destination delivery:

Segment automatically retries failed outbound requests. If failure rates to a specific downstream destination exceed 50% for more than 72 hours, or if more than 1,000 requests per second to that destination fail, Segment may reduce its retry volume until the condition resolves.

Public API (management calls):

Rate limits exist per endpoint and per token. Different endpoints carry different limits, but specific numbers (requests per minute, burst limits) are not documented in the public reference.

Rate-limit errors return standard HTTP 429 responses with Retry-After guidance. The Public API offers higher rate limits than the legacy Config API.

The Tracking API limit of 1,000 events per second is adequate for most applications. High-traffic consumer platforms processing millions of events daily may need to negotiate higher limits directly. The lack of published Public API rate limits is a real gap: you discover the limits by hitting them, so your first production integration needs defensive retry logic from the start.

Segment API Pricing & Access Costs

Segment uses a usage-based pricing model tied to Monthly Tracked Users (MTUs).

An MTU is any unique user who generates at least one event in a calendar month. Seats are unlimited on paid plans. Pricing splits across two product lines.

Customer Data Pipeline (Connections)

Free Plan ($0/month):

• 1,000 MTUs

• 2 sources, 1 warehouse destination

• 500,000 Reverse ETL records/month

• Access to 700+ integrations

• 10 seats

• Tracking API access included

• Public API not included

Team Plan (starts at $120/month):

• 10,000 MTUs base

• Unlimited sources, 1 warehouse destination

• 1,000,000 Reverse ETL records/month

• Public API access included

• 14-day free trial available, no credit card required

• Annual billing saves up to 20%

Team Plan MTU overages scale by volume band: $12 per 1,000 additional MTUs at 10K-25K, $11 at 25K-100K, $10 at 100K+.

Business Plan (custom pricing):

• Custom MTU volume, unlimited sources and warehouse destinations

• Protocols (data governance), advanced roles and permissions

• HIPAA eligibility, regional data residency

• Dedicated support and Customer Success Manager

Full CDP (Connections + Unify + Engage)

The full CDP adds identity resolution (Unify), audience building and journey orchestration (Engage), and AI features (Predictions, Recommendations, Generative Audiences).

Source: Twilio

Pricing is not publicly listed and requires a sales conversation. No self-serve trial is available for the full CDP.

What API Access Actually Costs

For a developer sizing costs, the critical detail is that the Tracking API (event ingestion through source SDKs) is available on every tier, including free. The Public API (workspace management) requires the Team plan at $120/month minimum.

The Profile API requires the Unify add-on, available on Business tier and above, which is enterprise-priced.

Functions are billed by execution time. The platform measures usage against three metrics: MTUs, API calls (each event counts as one call), and compute credits for Engage features.

The cost trap at scale is MTU-based pricing. For a high-traffic consumer application generating millions of page views, the MTU count grows with your user base whether those users convert or not. At overage rates of $10-12 per 1,000 additional MTUs, a 500,000-MTU application on the Team plan would incur roughly $5,000-6,000/month in overages alone, before accounting for any Business tier features.

Where the Segment API Falls Short

These are scope decisions and practical constraints a developer should plan around, not failures of the platform.

The Public API is paywalled. The free tier includes Tracking API access (event ingestion through source SDKs), but the Public API for workspace management is not available until the Team plan at $120/month. A developer evaluating the API before committing budget can test event ingestion but cannot programmatically manage sources, destinations, or tracking plans without a paid subscription.

Public API rate limits are not published. The Tracking API's 1,000 events/sec limit is clearly documented. The Public API's per-endpoint limits are not. The documentation states that different endpoints carry different rate limits and that you will receive a 429 with Retry-After guidance, but provides no specific numbers.

A developer planning a production integration that creates sources or manages destinations at scale discovers the limits empirically.

No B2B intelligence data. Segment collects and routes first-party behavioral data. It does not provide contact enrichment, company attributes, org charts, technographics, buyer intent signals, direct-dial phone numbers, or any third-party B2B intelligence. If your data pipeline needs to answer "who is this user, what company do they work for, and are they in-market," that data must come from another API.

Profile API is gated behind enterprise pricing. The Profile API with sub-200ms response times is one of Segment's most useful developer features, but it requires the Unify add-on, available only on the Business tier or the full CDP plan. Neither tier publishes pricing, and neither offers a self-serve trial.

MTU pricing penalizes traffic, not value. The MTU model charges for every unique user who generates an event, regardless of whether that user converts, purchases, or generates revenue. High-traffic consumer applications with low conversion rates can see costs scale out of proportion to business value.

Config API is a dead end. The Config API still works but receives no new features. Integrations built on it will need migration to the Public API. The two APIs use different authentication methods (Basic Auth vs. Bearer Token) and different identifier schemes (slugs vs. unique IDs), so migration is not a find-and-replace.

Webhook delivery guarantees are undocumented. The Extensible Webhook destination supports outbound event delivery with OAuth 2.0 and custom payloads, but the documentation does not describe retry counts, delivery attempts, or payload signing. For pipelines that depend on guaranteed delivery, you need to build your own reliability layer on top.

ZoomInfo API: The B2B Intelligence Layer Segment Does Not Cover

Segment tells you what a user did on your website, in your app, and across your product.

ZoomInfo tells you who that user is, what company they work for, what technology stack that company runs, whether the account is researching your category, and where the buyer sits in the org chart.

The two APIs operate at different layers of a data pipeline. The gap between "user_123 visited the pricing page" and "user_123 is the VP of Engineering at a 500-person SaaS company that just raised a Series C and is researching your competitor" is where ZoomInfo's API fits.

What the API Covers: Search, Enrichment, and AI Intelligence

ZoomInfo's Enterprise API is a REST suite served from https://api.zoominfo.com/gtm, organized into four surface areas documented in the interactive API reference:

Source: ZoomInfo

Data API (Search and Enrich) is the core surface. Search endpoints cover Contacts, Companies, Intent, News, and Scoops, returning matched records without consuming credits. Enrich endpoints unlock the full payload: business emails, direct dials, employment history, corporate hierarchy, org charts, technographics, and hashtag signals, accepting up to 25 records per call.

The search-then-enrich pattern means you filter freely, then pay only for the records you commit to. The underlying dataset spans 500M contacts and 100M companies, 135M+ verified phone numbers, and 200M+ verified business email addresses.

Copilot API exposes the GTM Context Graph (ZoomInfo's intelligence layer that processes 1.5B+ data points daily) as programmatic endpoints. Account Summary returns structured account intelligence with a free-form Q&A endpoint.

Find Similar Companies performs lookalike expansion from a seed account. Contact Recommendations returns AI-ranked buying-committee suggestions by motion (prospecting, deal acceleration, renewals).

Marketing API provides CRUD endpoints for programmatic audience management.

Platform API (Engagements, Beta) supports bidirectional engagement data via the Engagements API.

The pairing with a CDP API is direct: Segment collects behavioral events from your application, and ZoomInfo enriches the identities behind those events with B2B intelligence.

A developer could use Segment's Tracking API to capture a user's product behavior, then call ZoomInfo's Enrich endpoint to append company data, org chart position, and intent signals to that user's profile, either through a Segment Function or in a downstream enrichment pipeline.

Authentication, Rate Limits & Credits

Authentication uses OAuth 2.0 with PKCE via Okta, issuing 24-hour access tokens with rotating refresh tokens.

Three flows are supported: Authorization Code with PKCE (for web applications), Client Credentials (for server-to-server), and Refresh Token. Applications register through the ZoomInfo Developer Portal, where teams generate credentials, define scopes, and test endpoints.

Rate limits are published by tier: Builder (5 req/sec), Standard (25 req/sec), and Scaling (35 req/sec), with per-hour and per-day sliding-window limits enforced simultaneously.

Every response includes quota headers with remaining capacity, and 429 responses include a Retry-After header with exact backoff timing. Credits follow a rolling 12-month window: a record enriched for the first time consumes one credit; re-enriching the same record within the year is free.

Webhooks, MCP & Developer Experience

Webhooks are available via the Agents API, tied to ZoomInfo's Agent Teams system: event types cover bulk enrichment jobs completing, records changing, credit usage crossing thresholds, and new GTM signals (scoops, funding events, intent spikes) becoming available, with retry behavior and throttling configurable per event type.

For developers building AI agents, ZoomInfo's MCP server at https://mcp.zoominfo.com/mcp exposes search, enrich, and account research as native tools for MCP-compatible assistants, currently supporting Claude and ChatGPT. The credit model carries over from the REST API.

Source: ZoomInfo

ZoomInfo does not publish official SDKs, so you integrate over HTTP and own the auth-and-retry layer yourself. The interactive API reference supports live testing, and a Docs MCP server lets AI development tools generate integration code against the API spec.

Documentation is at docs.zoominfo.com. ZoomInfo added API access to all relevant plans in 2025, though pricing remains custom-quoted.

BDO Canada reported an 87% reduction in time spent updating internal data dashboards using the ZoomInfo API, with one analyst describing the integration as plug-and-play across any process. (ZoomInfo)

Final Verdict

Segment's API does its core job well: collecting first-party behavioral data through source SDKs in 10+ languages, managing data infrastructure programmatically through a versioned Public API, and querying identity-resolved profiles in real time.

The documentation is solid, SDK coverage is broad, and the 750+ integration catalog means your destinations are likely already supported. The free tier lets a developer test event ingestion immediately, and the Tracking API's 1,000-events-per-second limit is adequate for most production workloads.

Choose the Segment API if you are building a customer data pipeline: instrumenting behavioral tracking across web, mobile, and server, routing events to downstream tools and warehouses, managing data governance via tracking plans, and querying unified customer profiles for real-time personalization.

The API is the programmatic surface of a mature CDP, and for teams with the engineering capacity to implement it correctly, the investment compounds as every new destination or source plugs into the same instrumentation.

Choose the ZoomInfo API when your pipeline needs to go beyond behavioral data into who these users are, what companies they represent, what technology those companies use, and whether those accounts are in-market.

The search-then-enrich pattern (search is free, enrich consumes credits) and the Copilot API's AI intelligence endpoints cover the B2B intelligence domain that Segment's API was never designed to address. Together, the two APIs give you both the behavioral pipeline and the business intelligence layer.

Start with the ZoomInfo Enterprise API or explore the developer docs to see the endpoint surface directly.

A developer who needs neither should consider that Segment does not provide B2B intelligence data, and ZoomInfo does not collect or route behavioral events. If your pipeline requires both layers, the two APIs are complementary, not competing surfaces.

FAQ

Is the Segment API free?

Partially. The Tracking API (event ingestion through source SDKs) is available on the free tier with 1,000 Monthly Tracked Users, 2 sources, and 1 warehouse destination.

The Public API for workspace management is not available on the free tier; it requires the Team plan starting at $120/month. The Profile API requires the Unify add-on, available only on Business tier and above at custom pricing. A 14-day free trial of the Team plan is available with no credit card required.

Does Segment have a GraphQL API?

No. Segment exposes REST APIs that return JSON. The Tracking API at api.segment.io accepts event data following the Segment Spec. The Public API at docs.segmentapis.com manages workspace resources. The Config API at reference.segmentapis.com is the legacy management surface. There is no GraphQL endpoint for any of these surfaces.

What is the Segment API rate limit?

The Tracking API is limited to 1,000 events per second per workspace, with up to 10,000 properties per individual event. Higher limits can be requested by contacting Segment.

The Public API has per-endpoint rate limits that are not publicly documented; rate-limit errors return 429 responses with Retry-After guidance. Outbound destination delivery is automatically retried, but Segment may reduce retry volume if failure rates to a destination exceed 50% for more than 72 hours.

Are there official Segment SDKs?

Yes, across two categories. Source SDKs for event ingestion cover JavaScript, Swift, Kotlin (Android), React Native, Flutter, Unity, Xamarin, Node.js, Python, Ruby, PHP, Go, Java, .NET, Clojure, plus an HTTP API and Pixel Tracking API.

Public API management SDKs cover JavaScript, TypeScript, Go, Java, Swift, and C#. All are maintained by Segment/Twilio and hosted on GitHub under the segmentio organization.

Does the Segment API support webhooks?

Not in the traditional inbound sense. Segment provides outbound webhook destinations (the Extensible Webhook destination and the older Webhooks Actions destination) that push Segment events to external URLs, with configurable authentication including OAuth 2.0.

For inbound webhooks, Source Functions let you write JavaScript that receives webhooks from external systems and translates them into Segment events. Neither outbound webhook destination publishes retry counts or delivery-guarantee SLAs.

What does ZoomInfo's API add to a Segment build?

ZoomInfo's API adds the B2B intelligence layer that Segment's API does not cover. Segment collects behavioral data (what users do); ZoomInfo provides the identity and company intelligence behind those users (who they are, where they work, what technology their company uses, whether they are in-market).

A developer can use ZoomInfo's search endpoints to find contacts matching an ICP, enrich them with direct dials, org charts, technographics, and intent signals, then push that enriched data into Segment as a source or use it alongside Segment data in downstream systems.

The two APIs use different authentication models (Write Key/Bearer token vs. OAuth 2.0) and different pricing structures (MTU-based vs. consumption-based), so plan the integration layer accordingly. ZoomInfo's MCP server extends the same data to AI-agent workflows, adding a programmatic intelligence layer that Segment's event pipeline does not offer.