Adobe Experience Platform API: Full 2026 Review

The question behind an Adobe Experience Platform API integration is not whether the surface area exists, but whether your build can absorb the architectural commitment that comes with it.

Adobe Experience Platform's API is one of the most extensive in enterprise marketing technology. Built on an explicit "API first" philosophy where every UI capability is also available via REST, the developer documentation spans Experience League, a dedicated API developer hub, interactive reference pages with live "Try it" blocks, and Postman collections. The platform powers one trillion experiences per year across the brands running on it.

But breadth of surface and fitness for your specific build are different questions.

Adobe Experience Platform's API handles customer data operations: ingesting data from any source (batch and streaming), resolving identities into unified real-time profiles, building and evaluating audience segments across streaming, batch, and edge modes, activating those audiences to hundreds of downstream destinations, enforcing data governance policies at the point of activation, and running SQL analytics against the data lake. What it does not do is generate B2B intelligence. There are no endpoints for contact discovery, company enrichment, org chart traversal, technographic lookup, buyer intent detection, or verified phone number retrieval. AEP unifies and activates data you bring to it; it does not produce the B2B intelligence data itself.

This is where ZoomInfo enters the picture. ZoomInfo is a GTM platform whose Enterprise API is a REST suite covering search, enrichment, and AI intelligence across 500M contacts, 100M companies, 135M+ verified phone numbers, and 200M+ verified business email addresses. With OAuth 2.0 authentication, tiered rate limits up to 35 req/sec, and an MCP server for AI-agent workflows, ZoomInfo's API provides the B2B intelligence layer that AEP's customer data platform is not designed to produce.

This review covers the Adobe Experience Platform API in full technical depth first, then reviews ZoomInfo's API as the intelligence layer that supplies what AEP cannot.

Adobe Experience Platform API at a Glance

Adobe Experience Platform API: What Works Well & What to Plan Around

Adobe Experience Platform API: Authentication & Getting Started

Source: Adobe

API access starts with a licensed Adobe Experience Platform subscription. There is no free tier, no self-serve developer signup, and no public trial that includes API access. An administrator must assign developer and user roles to an Experience Platform product profile in Adobe Admin Console before a developer can create API integrations.

You obtain credentials by creating a project in Adobe Developer Console, adding the Experience Platform API, and selecting the OAuth Server-to-Server authentication type. The previously supported Service Account (JWT) method was deprecated, and existing JWT integrations were required to migrate by June 30, 2025.

Every API call requires three headers:

• Authorization: Bearer {ACCESS_TOKEN}: a bearer token that must be regenerated every 24 hours

• x-api-key: {API_KEY} (Client ID): generated once via Developer Console and reusable

• x-gw-ims-org-id: {ORG_ID}: your Adobe organization identifier

Most API calls also require an x-sandbox-name header to target the correct sandbox environment. A basic authenticated request follows this pattern:

curl -X GET "{API_ENDPOINT}" \

-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \

-H "x-api-key: YOUR_API_KEY" \

-H "x-gw-ims-org-id: YOUR_ORG_ID" \

-H "x-sandbox-name: prod"

Since the November 2024 release, you can also generate credentials directly from API reference pages by signing in and selecting "Create new credential." This provides a "Try it" interactive block for live API calls without leaving the documentation. Postman collections are available for testing.

Two services use separate credential flows from the main platform APIs: the Privacy Service API and the Reactor (Tags) API. Plan for a dedicated credential setup if your build touches either.

Adobe Experience Platform API: Core Endpoints & Capabilities

The API developer hub lists 15+ service-specific APIs, each with its own reference.

All use the same three-header authentication model, support JSON Pointer and JSON Patch (RFC 6901/6902) for addressing and partial updates, and require data to conform to the Experience Data Model (XDM) standard. Sandbox scoping applies to most calls.

Data Ingestion & Sources

The ingestion layer accepts data in two modes, both feeding into a shared XDM-compliant Data Lake.

Batch ingestion handles bulk historical loads and scheduled pulls. The Batch Ingestion API accepts files (CSV, JSON, Parquet) directly, with a maximum batch size of 100 GB and up to 20 GB/hour throughput via API. Source connectors via the Flow Service API pull from 70+ external systems on a schedule, with batch sources supporting up to 200 GB/hour.

A Data Landing Zone (Adobe-provisioned cloud storage, 7-day file retention) supports push-then-ingest workflows.

Streaming ingestion pushes data in real time via the Web SDK, Mobile SDK, or HTTP API, routed through the Edge Network using datastream configuration objects. Throughput: 4,000-5,000 req/sec to the data lake, 1,500 req/sec to profile, with a recommended record size of 10 KB.

Supporting APIs handle the data pipeline between source and lake:

• Data Prep API: field-level mapping and transformation from source schemas to XDM, including calculated fields and streaming upserts.

• Catalog Service API: metadata management for datasets and batches.

• Data Access API: download ingested dataset files.

Source connectors span Adobe applications (Analytics, Audience Manager, Marketo Engage, Campaign, Commerce), cloud storage (Amazon S3, Azure Blob, SFTP), CRM (Salesforce, Microsoft Dynamics), databases (Snowflake, BigQuery, PostgreSQL), and streaming platforms (Amazon Kinesis, Azure Event Hubs, Google PubSub).

Advanced Enterprise Sources (Kinesis, Event Hubs, BigQuery, Snowflake streaming, Databricks) require Real-Time CDP Ultimate licensing.

What you would build with this: a pipeline that streams web and mobile events via a single SDK call, batch-imports CRM records from Salesforce nightly via a scheduled source connector, and transforms both into unified XDM profiles without custom ETL middleware.

Real-Time Customer Profile & Identity Resolution

The Identity Service API manages identities, namespaces, and identity graph clusters.

It links different identifiers (CRM IDs, device IDs, email addresses, cookies) deterministically based on observed co-occurrences, building a per-organization identity graph with a hard limit of 50 identities per graph. Organizations can create custom namespaces for proprietary identifier schemes.

Source: Adobe

Real-Time Customer Profile merges identity-linked data fragments into a single profile per customer. Profile data comes in two types:

• Record data: attributes (name, email, demographics) modeled on the XDM Individual Profile class.

• Time-series events: behavioral actions modeled on the XDM ExperienceEvent class.

Merge policies control how the platform resolves conflicting attribute values from multiple datasets, configurable via API or UI (up to 3 per sandbox). The union schema provides a merged view across all Profile-enabled datasets. B2B entity support extends the profile model to accounts and opportunities linked to person profiles through schema relationships.

What you would build with this: an identity resolution layer that stitches anonymous web sessions (by cookie ID) to known CRM contacts (by email), creating a single addressable profile that updates in real time as new events arrive.

Segmentation & Audiences

The Segmentation Service API creates and manages audience definitions compiled into Profile Query Language (PQL), Adobe's declarative language for profile retrieval. Three evaluation modes cover the latency spectrum:

• Streaming segmentation: audience membership updates continuously as data lands, in near real time.

• Batch segmentation: the platform evaluates all profiles against segment definitions every 24 hours or on demand.

• Edge segmentation: evaluation on Adobe's Edge Network at the moment of a web or mobile request, enabling same-page personalization with sub-millisecond latency.

Audience Composition provides workflows for combining, enriching, and splitting existing audiences. Federated Audience Composition queries enterprise data warehouses (Snowflake, Databricks, Redshift) to build audiences without copying data into AEP. External audience import supports audiences built by data science models or third-party tools.

What you would build with this: a real-time audience that qualifies customers who viewed a product page but did not purchase within 24 hours, evaluated continuously via streaming segmentation and activated immediately to a retargeting destination.

Destinations & Activation

The Flow Service API for Destinations connects AEP to downstream platforms. Destination types include:

• Streaming audience export: near-real-time audience membership events via API to platforms like Facebook, Google Ads, and Google Display & Video 360.

• Batch (file-based): scheduled CSV exports to cloud storage (Amazon S3).

• Edge personalization: sub-millisecond evaluation on the Edge Network for same-page personalization (Adobe Target, Custom Personalization).

• Advanced enterprise streaming: continuous data streams to Amazon Kinesis, Azure Event Hubs, HTTP API, and Snowflake (Real-Time CDP Ultimate only).

The Destination SDK lets technology partners and Real-Time CDP Ultimate customers build and publish custom destination connectors. Real-Time CDP Ultimate customers can also build private custom destinations for internal systems.

Data governance enforcement evaluates data usage labels and marketing action policies at the moment of activation, blocking policy-violating exports before any data leaves. Attribute-based access control restricts field-level export rights, so users cannot export fields they lack access to even if the destination is otherwise permitted.

Data Governance, Privacy & Platform Operations

The Dataset Service API manages data usage labels at the schema field level, classified into Contract, Identity, and Sensitive categories. Labels propagate automatically to all datasets using that schema and downstream to any derived segments or profiles. Custom labels can extend the framework to organization-specific needs.

The Privacy Service API automates GDPR and CCPA data subject access and deletion requests across Adobe Experience Cloud applications from a single interface. The Data Hygiene API schedules dataset expirations and record-level deletions. Audit logs (queryable via the Audit Query API) record who did what and when across all platform resources.

Additional platform operations APIs:

• Sandbox API: create, read, update, and reset sandbox environments programmatically.

• Access Control API: view available and active user permissions.

• Observability Insights API: metrics, health checks, and performance indicators across all services.

Query Service & Analytics

The Query Service API exposes every dataset in the AEP data lake through standard ANSI SQL, without requiring data movement. Interactive queries return up to 50,000 rows within a 10-minute timeout. Adobe-defined functions (ADFs) extend standard SQL with XDM-native constructs for sessionization, event pathing, and time-gap analysis.

Multiple client paths work: the browser-based Query Editor, a PostgreSQL-compatible PSQL client, BI tools (Tableau, Power BI, Looker) over the Postgres wire protocol, and the REST API.

The Data Distiller add-on unlocks write-back queries (CTAS) that persist results as new datasets, scheduled batch transformation jobs, and derived datasets that feed back into Real-Time Customer Profile. It turns Query Service into a SQL-based transformation engine inside AEP, with compute-hour metering against license entitlements.

What you would build with this: a daily SQL job that computes churn propensity scores from event data, writes results back as a derived dataset, and feeds those scores into Real-Time Customer Profile for immediate audience qualification and activation.

Adobe Experience Platform API: Webhooks & Events

Adobe Experience Platform does not expose direct outbound webhooks. Event notifications arrive through Adobe I/O Events. Developers register a webhook endpoint in Adobe Developer Console; when an alert condition fires, the system sends a message to that endpoint.

Alert types fall into two categories:

One-time alerts cover discrete events:

• Data ingestion completed successfully

• Query execution finished

• Data deleted

Repeating alerts cover persistent anomaly states:

• Ingestion duration exceeding SLA

• Daily ingestion not occurring

• Stream processor error rate above threshold

Source: Adobe

Alert conditions are based on Observability Insights metrics (such as timeseries.ingestion.dataset.batchfailed.count). Each rule can include a time window and repeat frequency. Alerts also appear in the platform UI via a notification bell icon and can be forwarded to Slack through an App Builder proxy.

Two things to plan around:

• The event model is alert-based, not resource-event-based. There is no equivalent of "fire a webhook when a profile enters an audience" or "notify on every new record ingested."

• If your pipeline needs fine-grained, resource-level event streaming, the advanced enterprise destinations (Amazon Kinesis, Azure Event Hubs) on the Real-Time CDP Ultimate tier provide continuous data streams, but these are activation channels, not a general-purpose event bus.

Adobe Experience Platform API: SDKs, Docs & Rate Limits

SDKs & Libraries

Adobe provides first-party SDKs for client-side data collection, not for server-side API interactions:

• Experience Platform Web SDK: JavaScript SDK for browser-based data collection via the Edge Network. Replaces multiple per-product tags with a single implementation that feeds AEP, Adobe Analytics, Adobe Target, and other services simultaneously.

• Experience Platform Mobile SDK: iOS and Android SDKs for mobile app data collection.

• Edge Network Server API: server-side API for data collection and personalization without client-side SDKs.

For platform API interactions (ingestion, profile management, segmentation, destinations, governance), there are no server-side SDK packages in any language. Developers call the REST APIs directly using standard HTTP clients. Adobe provides Postman collections and interactive "Try it" blocks on API reference pages, but you own the authentication layer, token refresh logic, retry handling, and request serialization in production.

Two extension frameworks exist for building connectors: the Sources SDK (batch and streaming variants) lets partners build and register source connectors, and the Destination SDK lets partners build destination connectors. These are extension APIs for the connector catalog, not client libraries for consuming the platform APIs.

Documentation & Developer Experience

Adobe Experience Platform has one of the most thorough documentation ecosystems in enterprise software:

• Adobe Experience League: the primary hub, organized by product area with guides, tutorials, and embedded video walkthroughs.

• Adobe Developer Hub: dedicated API reference site listing all APIs with endpoint-level documentation.

• Interactive API explorer: available since November 2024 on API reference pages, letting developers sign in, generate credentials, and make live API calls directly in the docs.

• OpenAPI/Swagger specs: referenced on API reference pages; the "Try it" environment runs on these specs.

• Postman collections: available for testing API calls with authentication environments provided.

• Release notes: published on Experience League with "Last update" dates on each page.

Developer support runs through Adobe customer care representatives. Sandboxes (1 production + up to 4 non-production at base entitlement) let developers test integrations without affecting production data.

The documentation is thorough and developer-oriented, but the scope creates its own challenge.

Navigating 15+ service-specific API references, each with its own endpoint catalogue, authentication nuances, and guardrails, takes significant orientation time. Users on SelectHub note that "integrating with non-Adobe software can feel difficult and documentation can be confusing."

Rate Limits & Constraints

Adobe publishes ingestion guardrails at the organization level (not per sandbox, except where noted):

Batch ingestion via API:

• Up to 20 GB/hour to the data lake

• 1,500 files per batch

• Batch size cap: 100 GB

• Properties/fields per row: 10,000

• Batches per minute per user: 2,000 (soft limit)

Batch ingestion via source connectors (S3, Blob, SFTP):

• Up to 200 GB/hour

• Batch size: 256 MB to 100 GB

Streaming ingestion:

• 4,000-5,000 requests/second to the data lake

• 1,500 requests/second to profile or streaming segmentation

• Record size cap: 1 MB (recommended: 10 KB)

Profile hard limits:

• ExperienceEvent size: 10 KB

• Record class size: 100 KB

• Identities per graph: 50 (profiles exceeding this are excluded from segmentation, exports, and lookups)

Query Service:

• Interactive queries: up to 50,000 rows, 10-minute timeout

• 1 concurrent user and 1 concurrent ad hoc query per sandbox at base entitlement

Adobe notes that these guardrails are subject to license entitlements specified in each customer's Sales Order. Customers who consistently exceed soft limits can license additional capacity. The License Usage Dashboard provides daily metric snapshots and a six-week rolling usage forecast updated weekly.

Adobe Experience Platform API Pricing & Access Costs

Adobe Experience Platform does not publish pricing. There is no pricing page, no self-serve signup, and no public rate card. All deals go through Adobe's enterprise sales team via custom quote.

Pricing is usage-based, metered against two dimensions:

• Addressable Audience: the total number of customer profiles (known and pseudonymous) the organization can store, per Adobe's license documentation.

• Total Data Volume: calculated as Addressable Audience multiplied by Average Profile Richness, representing total data available for profile workflows, per Adobe's metric documentation. Data Lake storage is excluded from this calculation.

The unit of sale is per 1,000 Profiles. There is no flat-fee or per-seat pricing model.

The primary commercial vehicle is Real-Time CDP, sold in three audience editions (B2C, B2B, B2P), each with two package tiers: Prime and Ultimate. The tier difference matters for API builders:

• Ultimate unlocks: Advanced Enterprise Source and Destination Connectors, Profile API Calls (5 per profile/year for B2C, 8 for B2B), Destination SDK for custom connectors, and higher data export limits (700 KB/profile/year vs. 500 KB).

• Prime excludes: all of the above.

Baseline entitlements included with all editions:

• 5 sandboxes (1 production + 4 non-production)

• 75 KB average profile richness baseline

• 1 concurrent Query Service user, 1 concurrent ad hoc query

• Up to 3 Profile Merge Policies

• 1 batch segmentation job per day per production sandbox

A large catalog of purchasable add-ons exists, each priced separately: additional ad hoc query users (per pack of 5), extra sandboxes (per 10-pack), streaming segmentation capacity, computed attributes, Customer AI, Federated Audience Composition, Healthcare Shield (HIPAA compliance), Privacy and Security Shield, Profile Richness packs (+25 KB per profile), Data Distiller, and the Agent Orchestrator.

Overage policy: overusage is calculated daily, with a Grace Period of up to 7 consecutive days before fees kick in.

For a developer sizing this: there is no way to evaluate or prototype against the API without an enterprise contract. The Initial Implementation Period gives limited complimentary access before the license term begins, but only after a purchase agreement is signed. Non-production sandboxes support up to 10% of the licensed profile commitment for development and testing.

Where the Adobe Experience Platform API Falls Short

These are the practical limits a developer should plan around, several of which reflect AEP's enterprise positioning.

No free tier, no self-serve, no way to prototype before signing.

Every competing CDP and data platform offers some form of developer sandbox, free tier, or self-serve trial. AEP requires an enterprise contract before a developer can make a single API call. Teams evaluating the platform must make architectural decisions on documentation review alone.

No server-side SDKs for platform API interactions.

The Web SDK and Mobile SDK handle client-side data collection, but for server-side integrations (ingestion, profile management, segmentation, governance), developers work with raw HTTP calls.

You own the token rotation (every 24 hours), the retry logic, the error handling, and the three-header authentication on every request. Postman collections help with prototyping, but there is no maintained Python, Node.js, or Java client library to absorb that overhead in production.

Three-header authentication on every call.

Bearer token, API key, and org ID must accompany every request, plus a sandbox header for most calls. The access token's 24-hour expiry means every long-running integration needs a reliable token refresh mechanism. This is more friction than most modern APIs impose.

Advanced connectors require Ultimate licensing.

The advanced enterprise connectors (Amazon Kinesis, Azure Event Hubs, Snowflake streaming, Google BigQuery, Azure Databricks) and Advanced Enterprise Destination Connectors are exclusive to Real-Time CDP Ultimate. A developer building on the Prime tier discovers that their preferred data warehouse connector sits behind a tier gate.

Alert-based events, not resource-level webhooks.

The Adobe I/O Events system delivers alerts on health metrics and job completions, but it is not a general-purpose event system. There is no "fire a webhook when a profile enters an audience" or "notify on every new identity link."

Developers who need real-time, event-driven architectures must use the advanced enterprise streaming destinations (Kinesis, Event Hubs) on the Ultimate tier, which are activation channels, not webhook infrastructure.

No B2B intelligence endpoints.

AEP ingests, unifies, and activates data. It does not generate it. There are no endpoints for contact discovery, company enrichment, technographic lookup, buyer intent signals, org chart traversal, or verified phone number retrieval. If your customer data pipeline needs B2B intelligence as an input, that data must come from an external source.

Implementation complexity is structural, not incidental.

All data must conform to XDM schemas before ingestion. Schema design, identity namespace planning, and merge policy configuration are prerequisites before the first record enters the system. TrustRadius reviewers describe the platform as one where "you need to be well trained and resourced to use the product," and implementation timelines of 6 to 18 months are typical for enterprise deployments.

ZoomInfo API: The B2B Intelligence Layer AEP Does Not Generate

AEP's API manages the customer data platform: ingesting, unifying, segmenting, and activating data from any source. What it does not produce is the B2B intelligence data that feeds those operations.

ZoomInfo's API covers that layer: contact discovery, company enrichment, intent signals, org charts, and technographics, all accessible programmatically. Powering those endpoints is the GTM Context Graph, which processes 1.5B+ data points daily by fusing ZoomInfo's B2B data with your first-party data to show not just what happened, but why.

Source: ZoomInfo

For a developer building a B2B pipeline on AEP, ZoomInfo's API is the intelligence source upstream of ingestion. The workflow: search for contacts matching your ICP (free, no credits consumed), enrich with verified emails, direct dials, and company data (1 credit per new record), then push the results into AEP via a source connector or the Batch Ingestion API for unification and activation.

What the API Covers: Search, Enrichment & AI Intelligence

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

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

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

Source: ZoomInfo

Copilot API (AI Intelligence): Exposes AI capabilities from GTM Workspace programmatically.

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). This surface requires an Enterprise API or Copilot package subscription.

Marketing API: CRUD endpoints for programmatic audience management, enabling automated audience refresh directly from pipeline systems.

Platform API (Engagements, Beta): Bidirectional engagement data via the Engagements API.

What you would build with this in an AEP pipeline: a pre-ingestion enrichment service that queries ZoomInfo for contacts matching your ICP, enriches matches with verified emails and company data, then batch-ingests the enriched records into AEP where they join the unified customer profile for segmentation and activation.

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 (web applications), Client Credentials (server-to-server), and Refresh Token. Teams register applications through the ZoomInfo Developer Portal, where they generate credentials, define scopes, and test endpoints.

Rate limits are published by tier: Builder (5 req/sec, 10,800/hour, 129,600/day), Standard (25 req/sec, 54,000/hour, 648,000/day), and Scaling (35 req/sec, 75,600/hour, 907,200/day).

All three windows (per-second, per-hour, per-day) are enforced simultaneously using a sliding window counter algorithm. Every response includes quota headers with remaining capacity, and 429 responses include a Retry-After header with exact backoff timing and an X-RateLimit-Rejected-Bucket header identifying which window was exhausted.

Source: ZoomInfo

Credits follow a rolling 12-month window: enriching a record for the first time consumes one credit; re-enriching the same record within the year is free. Search, lookup, and similarity operations are free and do not consume credits. ZoomInfo uses consumption-based pricing, custom-quoted per organization; ZoomInfo has added API access to all relevant plans.

MCP, Webhooks & Developer Experience

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. A separate Docs MCP server lets AI development tools generate integration code against the ZoomInfo API spec.

Source: ZoomInfo

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 and throttling configurable per event type.

Documentation lives at docs.zoominfo.com with an interactive API reference, OAuth recipes in five languages (Shell, Node, Ruby, PHP, Python), and an llms.txt index for AI development tools. ZoomInfo does not publish official SDKs either, so both ZoomInfo and AEP require direct HTTP integration. The interactive playground supports live testing with OAuth2 Bearer token authentication.

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

Adobe Experience Platform's API is the most thorough programmatic surface in the enterprise customer data platform category.

Fifteen-plus service-specific APIs cover every stage of the customer data lifecycle: ingestion through identity resolution, segmentation across streaming, batch, and edge modes, activation to hundreds of destinations with inline governance enforcement, and SQL analytics against a live data lake. The documentation is thorough, the guardrails are published, and the interactive API explorer lets a developer confirm response shapes without writing code.

Its limits are limits of positioning: enterprise-only access, no server-side SDKs, three-header authentication, and a scope that stops at data operations.

Choose the Adobe Experience Platform API if you are building customer data infrastructure at enterprise scale: ingesting from dozens of sources into unified real-time profiles, segmenting across three evaluation modes, activating to hundreds of destinations with data governance enforcement built into the activation layer, and running SQL analytics against a live data lake.

AEP's API is the right foundation when the build is customer experience orchestration and the organization is committed to the Adobe ecosystem.

Choose ZoomInfo's API when your pipeline needs B2B intelligence as an input to that customer data layer: contact discovery, company enrichment, org charts, technographics, and buyer intent signals.

ZoomInfo's search-then-enrich pattern (search is free, enrich consumes credits), its AI intelligence endpoints, and its MCP server give a developer the data AEP's API is not designed to produce. The two APIs sit at different layers of the same pipeline, and the build that needs both is more common than the build that needs only one.

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

A developer who needs a customer data platform but cannot commit to AEP's enterprise licensing should know that AEP has no lighter-weight API access tier. The platform is built for organizations already in the Adobe ecosystem with the budget and engineering resources to match.

FAQ

Is the Adobe Experience Platform API free?

No. API access requires a licensed Adobe Experience Platform subscription, sold through enterprise agreements with custom pricing. There is no free tier, no self-serve signup, and no public trial that includes API access.

New customers receive an Initial Implementation Period for testing before the license term begins, but only after signing a purchase agreement. The base entitlement includes 5 sandboxes, 1 concurrent Query Service user, and 3 Profile Merge Policies, with everything else (additional query users, sandboxes, streaming segmentation, Data Distiller) available as paid add-ons.

Does Adobe Experience Platform have a GraphQL API?

No. All Adobe Experience Platform APIs are RESTful, supporting CRUD operations over HTTPS with JSON responses. The platform uses JSON Pointer (RFC 6901) and JSON Patch (RFC 6902) for partial updates and resource mutations.

Query Service supports standard ANSI SQL against the data lake (with Adobe-defined functions for XDM-native constructs like sessionization and event pathing), but there is no GraphQL endpoint.

What are the Adobe Experience Platform API rate limits?

Rate limits vary by service.

Streaming ingestion supports 4,000-5,000 requests/second to the data lake and 1,500 requests/second to profile. Batch ingestion via API handles up to 20 GB/hour (200 GB/hour via source connectors). Profile guardrails enforce hard limits: 10 KB for ExperienceEvent records, 100 KB for record class records, and 50 identities per identity graph. Query Service allows 1 concurrent user and 1 concurrent ad hoc query at base entitlement.

Most limits apply at the organization level and are subject to license entitlements specified in the customer's Sales Order.

Are there official server-side SDKs for the Adobe Experience Platform API?

No. Adobe provides the Web SDK (JavaScript) and Mobile SDK (iOS/Android) for client-side data collection, plus the Edge Network Server API for server-side data collection.

For platform API interactions (ingestion, profile management, segmentation, governance, destinations), there are no maintained server-side SDK packages in any language. Developers call REST APIs directly using standard HTTP clients. Postman collections and interactive "Try it" blocks on API reference pages help with prototyping, but production integrations require building your own authentication, retry, and request-handling layer.

Does the Adobe Experience Platform API support webhooks?

Not in the traditional sense. Event notifications arrive through Adobe I/O Events, where developers register a webhook endpoint in Adobe Developer Console.

Alerts fire on health metrics and job completions (ingestion succeeded, query finished, data deleted, error rate above threshold), but there is no resource-level event system for fine-grained notifications like "a profile entered an audience" or "a new identity link was created."

Developers who need real-time event streaming typically use the advanced enterprise streaming destinations (Amazon Kinesis, Azure Event Hubs) on the Real-Time CDP Ultimate tier.

How does ZoomInfo's API complement the Adobe Experience Platform API?

ZoomInfo's API provides the B2B intelligence data that AEP's API does not generate. AEP ingests, unifies, and activates customer data, but it has no endpoints for contact discovery, company enrichment, org chart traversal, technographic lookup, or buyer intent detection.

ZoomInfo's search endpoints let you find contacts matching your ideal customer profile without consuming credits, enrich with verified emails, direct dials, and company data at 1 credit per new record, and detect intent signals across accounts. The enriched data can then flow into AEP via a source connector or the Batch Ingestion API, where it joins the unified customer profile for segmentation and activation.

The two APIs use different authentication models (three-header OAuth Server-to-Server vs. standard OAuth 2.0 with PKCE) and different pricing structures (enterprise license vs. credit-based), so plan your integration layer to handle both. ZoomInfo's MCP server extends the same intelligence to AI-agent workflows, adding a programmatic surface AEP does not currently offer.