Pendo API: Complete 2026 Review

Every product analytics API evaluation comes down to the same question: the platform captures behavioral data in its dashboard, but how much of that data can you pull into your own systems, feed your own models, or pipe into a custom workflow?

Pendo's API splits across two REST APIs (the Engage API for analytics and metadata, and the Feedback API for feature requests), a JavaScript Web SDK, and a newer MCP server for AI tool integration. The documentation is public, authentication is key-based, and the aggregation endpoint gives you access to the same behavioral data behind Pendo's dashboards.

But access and depth are different questions.

Pendo's API is a data-extraction and metadata-management layer for a product analytics platform. If you need to pull usage data into a warehouse, push visitor metadata back into Pendo, or manage guides programmatically, the API covers that ground. What it does not cover is the broader B2B intelligence stack: who those visitors are beyond what your application passes in, what companies they represent, whether those accounts show buying intent, and how to reach the people behind the usage data. That is a different data layer entirely.

This is where ZoomInfo enters the picture, a GTM platform whose Enterprise API covers search, enrichment, AI intelligence, and audience management across 500M contacts and 100M companies, with OAuth 2.0 authentication, tiered rate limits, and an MCP server for AI-agent workflows. It fills the identity and intelligence gap that a product analytics API, by design, does not address.

This review covers the Pendo API in technical depth first, then reviews ZoomInfo's API as the data layer that picks up where product analytics stops.

Pendo API at a Glance

Pendo API: What Works Well & What to Plan Around

Pendo API: Authentication & Getting Started

Pendo runs two separate APIs, each with its own authentication model.

Engage API: You create an integration key inside the Pendo application at Settings > Integrations > Integration Keys. The key is passed as the x-pendo-integration-key HTTP request header on every request. You can provision keys as read-only (default) or read-write (by enabling "Allow Write Access" at creation).

Pendo displays each key only at creation time; if you lose it, you must generate a new one. A subscription can hold any number of keys. Keys are subscription-wide, not scoped to a specific application, so one key accesses all apps in the subscription.

Source: Pendo

Feedback API: Uses a separate API key passed as the auth-token HTTP header (or as an auth-token query parameter). Feedback API keys are user-specific and generated in Pendo > Products > Feedback > Settings > Product Settings > API Access.

This is a different credential from the Engage API integration key and from the snippet key embedded in the Pendo install code.

Source: Pendo

A basic authenticated request to the Engage API looks like this:

curl -X POST "https://app.pendo.io/api/v1/aggregation" \

-H "x-pendo-integration-key: YOUR_INTEGRATION_KEY" \

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

-d '{"response":{"mimeType":"application/json"},"request":{"pipeline":[{"source":{"visitors":null}}]}}'

Two constraints to know before you build:

• No OAuth, no token rotation. Both APIs use static keys. Teams with credential-rotation policies or multi-tenant integrations that need delegated access will find this model limiting.

• Plan-gated access. The Engage API documentation states that access "is dependent on your level of service with Pendo." The Free tier (500 MAUs) does not list API access among its features. Confirm your plan includes API access before investing in an integration.

Pendo API: Core Endpoints & Capabilities

The Engage API covers four areas: aggregations (the primary query interface), visitor and account metadata, guide management, and server-side event ingestion. The Feedback API handles feature-request data separately.

Aggregations (Primary Query Interface)

Endpoint: POST /api/v1/aggregation

This is the core of the Pendo API. The aggregation endpoint accepts structured JSON query objects that specify a data source, filters, group-by fields, and time ranges. It queries the same behavioral data behind Pendo's UI reports, making it the primary route for extracting analytics programmatically.

Supported data sources include:

• PageEvents: page-level user interactions

• FeatureEvents: feature-level usage data

• TrackEvents: custom server-side and client-side events

• Visitors: visitor records with metadata

• Accounts: account records with metadata

• Guides: guide interaction data

You can aggregate results at the hour or day level. The query language is Pendo-specific (not SQL or GraphQL), and writing aggregation queries is documented on the Pendo engineering blog.

What you would build with this: a nightly export of feature adoption data into your warehouse, a custom dashboard combining Pendo usage data with revenue data from your CRM, or a churn-signal pipeline that flags accounts whose feature usage drops below a threshold.

Source: Pendo

Visitor & Account Metadata

Endpoint: POST /api/v1/metadata/visitor/custom/value

Endpoint: POST /api/v1/metadata/account/custom/value

These endpoints create or update custom metadata fields on visitor and account records. The ?create=true query parameter creates new visitor records. This is how you push data back into Pendo: adding CRM fields, subscription tiers, or custom attributes to visitor profiles.

The write direction matters. If your integration needs to keep Pendo's visitor records in sync with your user database (appending plan tier, company size, or lifecycle stage), these endpoints handle the push.

Guide Management

The API exposes CRUD operations on Guide objects: create, read, update, and delete in-app guides programmatically. Teams managing large guide libraries or automating deployment across multiple applications will use these.

Track Events (Server-Side Ingestion)

Pendo accepts server-side Track Events via API for backend actions that don't originate in the browser. This extends data collection beyond the client-side JavaScript snippet to cover API calls, backend processes, and mobile interactions the browser agent cannot observe.

Feedback API

The Feedback API covers Pendo's feedback product (formerly Receptive). It provides access to feature-request and user-feedback data, with endpoints supporting limit, start, and order parameters for cursor-style pagination. All responses are JSON.

This API uses its own authentication (the auth-token header) and lives at a different domain from the Engage API.

Pendo API: Webhooks & Events

Pendo classifies webhooks as a native "Connector" integration with "Data Out" direction. They push event data to external systems when specified user actions occur.

Key delivery behavior from Pendo's webhook documentation:

• Timeout: Webhook calls that exceed 5 minutes return a 408 error.

• Retry logic: Pendo retries up to five times when the receiving endpoint returns a 429 or any 5xx error.

• Auto-disable: If a webhook experiences repeated delivery failures, Pendo disables it automatically. Admins must re-enable it after resolving the receiving endpoint issue.

You configure webhooks in the Pendo UI. Pendo does not document any API endpoint for programmatic webhook management. You set specific trigger event types at setup time through the UI.

Two things to plan around:

• No programmatic webhook management. Unlike APIs that let you create, list, and delete webhooks via endpoints, Pendo requires UI configuration.

• Event type documentation is limited. The events available for webhook triggers are configured through the UI rather than enumerated in the public API documentation.

Pendo API: SDKs, Docs & Rate Limits

SDKs & Libraries

JavaScript Web SDK: Pendo's primary SDK, documented at agent.pendo.io. You can install it two ways:

• Install snippet (recommended): a JavaScript snippet that fetches the SDK at runtime and creates the global pendo object. You manage the version from the Pendo UI without redeploying.

• npm package: npm install @pendo/web-sdk. Bundles the SDK with the application; updating requires a redeploy.

Three builds support different browser environments: Standards (default, modern APIs), XHR (some legacy support), and JSONP (full legacy, including all IE versions). The SDK releases weekly, with changes shipping first to beta, then promoting to stable. An RSS feed at https://agent.pendo.io/releases/atom.xml tracks updates, and release notes appear at agent.pendo.io/versions.

Server-side SDKs: None. Pendo does not publish official server-side SDKs in Python, Ruby, Java, Go, or any other language. You consume the Engage and Feedback APIs directly via HTTP with any client. Pendo maintains a GitHub organization at github.com/pendo-io for the SDK and related tooling.

Source: Pendo

Mobile SDK: Mobile is listed as a platform capability, but specific mobile SDK documentation was not accessible from public developer pages.

Documentation & Developer Experience

Pendo operates a developer portal at developers.pendo.io as the entry point for integration builders. Documentation splits across several properties:

• Engage API reference: engageapi.pendo.io with an interactive collection format where you add the integration key once and it propagates to all request headers.

• Feedback API reference: feedbackapi.pendo.io, same format as the Engage API portal.

• Web SDK docs: agent.pendo.io covering installation, configuration, events, public functions, cookies, and advanced customization.

• Help Center API section: https://support.pendo.io/hc/en-us/articles/27862809568667-Pendo-developer-APIs

• Engineering blog: https://www.pendo.io/developers/ with technical articles, including the aggregation API tutorial.

• MCP setup guide: Step-by-step instructions for connecting Pendo's MCP server.

The developer site reports processing 6B+ events daily and reaching 290M+ monthly end users.

No Swagger/OpenAPI spec, Postman collection, or interactive API playground was publicly accessible. Pendo routes developer support through the Help Center and ticket system; there is no dedicated developer forum separate from the broader Pendo Community.

Rate Limits & Constraints

Pendo does not publish API rate limit numbers in its public documentation. This is a meaningful gap for a developer sizing an integration.

What is documented:

• Aggregation query timeout: Queries time out at 5 minutes, returning a 408 error. Complex queries against large datasets may need narrower time ranges or fewer dimensions.

• Throttling exists: Community discussions reference throttling behavior, and Pendo's webhook retry model confirms that rate limiting exists. The precise limits are not publicly stated.

• Subscription-tier enforcement: Actual rate limits appear to be set by subscription tier and enforced at the server level. Enterprise customers should confirm limits with Pendo's sales or support team before building a production integration.

The absence of published rate limits is itself a finding. A developer building a production pipeline against this API cannot capacity-plan without contacting Pendo directly.

Pendo API Pricing & Access Costs

Pendo does not publish standalone API pricing.

The pricing page lists "Integrations" as included in all plans, but the Engage API documentation states that API access "is dependent on your level of service with Pendo." The Free plan (up to 500 MAUs) does not list API access among its features.

What is confirmed:

• All paid tiers (Base, Core, Ultimate) carry custom pricing negotiated per subscription, with no published per-call or usage-based API metering.

• Write access via the API requires an integration key provisioned with "Allow Write Access," an account-level permission, not a separately priced capability.

• Data Sync (warehouse export to Snowflake, S3, Azure, Google Cloud Storage) comes with the Ultimate plan and may be available as an add-on for other tiers.

• Pendo prices by MAU (Monthly Active Users), so the platform cost scales with your user base. API access is bundled into the platform subscription, not metered separately.

For a developer sizing costs: there is no per-call API charge, but the minimum cost to access the API is whatever Pendo quotes for a paid plan at your MAU volume. Since all paid plan pricing sits behind a sales call, the API cost stays opaque until you talk to Pendo's sales team.

Where the Pendo API Falls Short

These are the practical limits a developer should plan around. Several are scope decisions that reflect what Pendo's API is (a data-extraction layer for a product analytics platform) and what it is not.

Pendo does not publish rate limits.

A developer cannot capacity-plan an integration without contacting Pendo directly. You discover throttling in production or by asking sales. For a platform processing 6B+ events daily, this is a notable gap.

No OAuth, no token rotation.

Both the Engage and Feedback APIs use static keys. No OAuth flow, no token expiration, no credential rotation, no scoped access. Teams with credential-rotation policies or multi-tenant integrations that need delegated access will hit this wall.

Two separate APIs with different auth mechanisms.

Analytics data lives in the Engage API (authenticated via x-pendo-integration-key), while feedback data lives in the Feedback API (authenticated via auth-token). The two APIs use different credentials, base URLs, and documentation portals. An integration that needs both behavioral and feedback data must manage two authentication paths.

No official server-side SDKs.

The JavaScript Web SDK ships weekly releases, but no official wrappers exist for Python, Go, Java, Ruby, or any other server-side language. You build and maintain the HTTP layer, authentication handling, and error logic yourself.

No Swagger/OpenAPI spec or Postman collection.

The API portals use an interactive collection format, but no downloadable OpenAPI spec, Postman collection, or machine-readable API description is available.

Scope is product analytics data.

The API gives you access to behavioral data Pendo captures (page views, feature clicks, guide interactions, visitor metadata). It does not provide B2B intelligence: who those visitors are beyond what your application passes in, what companies they represent, what those companies' tech stacks look like, whether they show buyer intent, or how to reach the decision-makers behind the usage data.

Webhook management is UI-only.

You cannot create, list, or delete webhooks via the API. Configuration requires manual work in the Pendo dashboard, which limits automation and infrastructure-as-code workflows.

ZoomInfo API: The Identity and Intelligence Layer Beyond Product Analytics

Pendo's API tells you what users do inside your application: which features they adopt, where they drop off, and how they respond to in-app guides. ZoomInfo's API tells you who those users are, what companies they work for, what technology those companies run, and whether those accounts are researching your category.

The two APIs sit at different layers of a data pipeline. A developer building a product-led growth stack would use Pendo's API to extract behavioral signals and ZoomInfo's API to identify and enrich the accounts behind those signals.

Source: ZoomInfo

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 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 return the full record: business emails, direct dials, employment history, corporate hierarchy, org charts, technographics, and hashtag signals, up to 25 records per call.

The underlying dataset spans 500M contacts and 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 the records you commit to.

Source: ZoomInfo

AI Intelligence (GTM Workspace Copilot): Account Summary returns structured account intelligence with a free-form Q&A endpoint. Find Similar Companies performs lookalike expansion. Contact Recommendations returns AI-ranked buying-committee suggestions by motion (prospecting, deal acceleration, renewals).

These endpoints run on the GTM Context Graph, which processes 1.5B+ data points daily by combining ZoomInfo's B2B data with your first-party data.

Source: ZoomInfo

The pairing with a product analytics API is direct: extract behavioral data from Pendo showing which accounts are most engaged (or at risk of churning), then use ZoomInfo's API to identify the stakeholders at those accounts and enrich them with contact data, org charts, and intent signals.

Authentication & Access

ZoomInfo uses OAuth 2.0 with PKCE via Okta, issuing 24-hour access tokens with rotating refresh tokens. It supports three flows: Authorization Code with PKCE (for web applications), Client Credentials (for server-to-server), and Refresh Token. Teams register applications through the ZoomInfo Developer Portal, where they generate credentials, define scopes, and test endpoints.

This is a different authentication model from Pendo's static key: it supports delegated access, credential rotation, and scoped permissions natively.

Rate Limits, Credits & Developer Experience

ZoomInfo publishes rate limits by tier: Builder (5 req/sec), Standard (25 req/sec), and Scaling (35 req/sec), enforcing per-hour and per-day sliding-window limits simultaneously. Every response includes quota headers with remaining capacity, and 429 responses include a Retry-After header with exact backoff timing.

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 and lookup operations are free and do not consume credits.

MCP Server & Webhooks

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

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, with retry behavior and throttling configurable per event type.

Documentation lives at docs.zoominfo.com with an interactive API reference, OAuth recipes in five languages, and an llms.txt index for AI development tools. ZoomInfo does not publish official SDKs, so both Pendo and ZoomInfo require direct HTTP integration. ZoomInfo has added API access to all relevant plans, with consumption-based pricing.

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

Final Verdict

Pendo's API gives you programmatic access to the behavioral data the platform collects: page events, feature adoption, guide interactions, visitor metadata, and feedback.

The aggregation endpoint covers the full behavioral dataset, the regional base URLs handle data residency, and the MCP server opens a path for AI-assisted product workflows. For a developer whose build starts and ends with product analytics data (warehouse syncs, custom dashboards, metadata enrichment), the API delivers what the dashboard does, without the dashboard.

Its limits are limits of scope and developer experience, not of the data itself. Unpublished rate limits, static key authentication, no server-side SDKs, no OpenAPI spec, and a split between two separately authenticated APIs add integration overhead that more developer-facing platforms have solved.

Choose the Pendo API if your integration is product-analytics-first: exporting behavioral data to a warehouse, syncing visitor metadata with your application, managing guides programmatically, or building custom reporting on feature adoption. The aggregation endpoint's access to the full behavioral dataset is the API's strongest capability.

Choose the ZoomInfo API if your build needs the identity and intelligence layer beyond product usage: determining which companies are behind the usage data, who the stakeholders are, what their tech stack looks like, and whether they are in-market. The search-then-enrich pattern (search is free, enrich consumes credits) and the AI intelligence endpoints (part of GTM Workspace) cover the data and reasoning that product analytics APIs do not.

Explore the ZoomInfo Enterprise API or start with the developer docs to see the endpoints directly.

A developer who needs neither API should consider that Pendo's API does not provide B2B contact or company intelligence, and ZoomInfo's API does not track in-product user behavior. If your pipeline needs both, they are complementary layers: Pendo captures the behavioral signal, ZoomInfo identifies and enriches the accounts behind it.

FAQ

Is the Pendo API free?

Not on the Free plan. Pendo's Free tier (up to 500 MAUs) does not include API access. The Engage API documentation states access depends on your subscription level. All paid plans (Base, Core, Ultimate) include API access, but pricing is custom-quoted through Pendo's sales team. There is no per-call or usage-based metering; the API is part of your platform subscription.

Does Pendo have a GraphQL API?

No. Pendo exposes two REST APIs (Engage and Feedback) that communicate over HTTPS and return JSON. The primary query interface is an aggregation endpoint that accepts structured JSON query objects, not GraphQL queries. If you need GraphQL, you must build a wrapper on top of the REST API.

What is the Pendo API rate limit?

Pendo does not publish rate limit numbers. Aggregation queries time out at 5 minutes (returning a 408 error), and community discussions reference throttling, but exact per-second or per-minute ceilings are not published. Subscription tier appears to determine rate limits, enforced at the server level. Contact Pendo's support or sales team to confirm the limits for your plan before building a production integration.

Are there official Pendo SDKs?

For the browser, yes. Pendo publishes a JavaScript Web SDK available via an install snippet or the npm package @pendo/web-sdk, with weekly releases, three browser-compatibility builds, and a versioned changelog.

For server-side languages, no. No official SDKs exist for Python, Go, Java, Ruby, .NET, or any other server-side language. Developers integrate with the REST APIs directly via HTTP. Pendo maintains a GitHub organization at github.com/pendo-io for the SDK and related tooling.

Does the Pendo API support webhooks?

Yes. Pendo pushes event data to external systems when specified user actions occur. Webhook calls time out at 5 minutes, Pendo retries up to five times on 429 or 5xx errors, and Pendo disables webhooks automatically after repeated delivery failures. You configure webhooks through the Pendo UI, not via API endpoints. Pendo documents no programmatic webhook management.

What does ZoomInfo's API add to a Pendo integration?

ZoomInfo's API adds the identity and intelligence layer that Pendo's API does not cover. Pendo tells you what users do in your product; ZoomInfo tells you who they are, what companies they work for, and whether those accounts are worth pursuing.

A practical pipeline: extract behavioral signals from Pendo's aggregation endpoint showing which accounts have declining feature adoption, then use ZoomInfo's search and enrich endpoints to identify the stakeholders at those accounts, pull their direct contact information, and check whether those companies show buyer intent or are researching competitors. ZoomInfo's MCP server extends the same data to AI-agent workflows, and search operations are free (enrich consumes credits).

The two APIs use different authentication models (static key vs. OAuth 2.0), so plan the integration layer to handle both.