Features

These are the features gathered across all of the companies we are looking at as part of this research, offering a comphrensive list of the capabilities of these companies, which is something we will work to normalize to more easily compare the offerings between companies.
1 Day Collection Recovery

100 Packages

100,000 Mock Server Requests

24/7 Logging

24/7 Monitoring

24/7 Tracking

25 Collection Runs

30 Day Collection Recovery

50 Free Activities in Postbot

600+ Connectors

90 Day Collection Recovery

Access API

Access Management

Access to Flows

Account Audit Log Streaming

Account Manager

Action Restrictions

Active Assurance

Active Automations

Active Connectors

Active Steps

Active Users

Activity History

Additional Features

Additional Transactions

Admininistrative Console

Advanced Admin Permissions

Advanced Analytics

Advanced Connector Rate Limiting

Advanced Observability

Advanced On-Prem

Advanced Request Tracing

Advanced Role-Based Access Control

Advanced Traffic Controls

Advanced Uptime Slas

Agent Design

Agent Management

Agent Orchestration

AI Agent Tooling

AI Agents

AI Agents and Models

AI API Testing

AI by Zapier

AI Code Steps

AI Content Writer

AI Custom Actions

AI Email Writer

AI for Integrations

AI Integration

AI Integration Agents

AI Troubleshooting

AI Website Generator

AI Workflows

AI-Guided Integration

Ai-Powered Document Assistance

Airbyte Adapter

Alerts

All Packages Include

Amazon Sqs

Amqp

Analytics

Analyze

Anget Marketplace

Annual Payment Discount

Annual Task Limits

API Admin

API Analsysis

API Analytics and Observability

API Authentication

API Budget Management

API Catalogs

API Connectors

API Consumption Auditing

API Consumption Observability

API Consumption Reporting

API Control Plane

API Design

API Developer Portal

API Discovery

API Documentation

API Editor

API Failover

API Federation

API Gateway

API Gateway Transaction Volume

API Governance

API Governance Manager

API Key Expiration

API Key Management

API Key Rotation

API Keys Post Expiration Window

API Management

API Mocking

API Monitoring

API Network Folder Manager

API Network Manager

API Performance Metrics

API Plans

API Productization

API Publishing

API Rate LImiting

API Requests Per Month

API Scaling

API Security

API Token Refresh

API Versioning

API Viewer

API-First

APIs.json Adapter

App Connectors

App Restriction

Application Connections

Application Integrations

Application Migration

Application Support

Apply Standards

Approval Requests

Arazzo Adapter

Artificial Intelligence

AS2

AsyncAPI Adapter

Audit Log

Audit Logging

Audit logs

Auth API

Auth Collector

Authentication

authorization

Auto-Scaling

Automate Deployments

Automated CI/CD

Automatic Alerts

Automatic Hardening

Automatic Structure Detection

Automation

Automation Designer

Automation Help Sessions

Automation Templates

Automation Update Time

Automations

Autoreplay

Autoscaling

AWS Lambda Router

AWS Marketplace

Backup and Recovery

Basic Role-Based Access Control

Breaking change detection

Broad Sdk Support

Build GraphQL APIs

Build Integrations

Bulk Data Migration

Business associate agreement

Cache Warmer

Caches

Capability Catalog

Catalog

Centralised Credential Management

Centralized Consumption

Choice of cloud

Choice of Regions

CI/CD

CLI

CLI (Command Line Interface)

CLI Tool

Clickable Poly Tree Links for Public Functions

Cloud-Based Integrations

Cloud-Native

Cluster Monitoring

Code connectors

Code Escrow Service

Code Generation

Code Reuse

Code-First Approach

Code-Native Integrations

Collaboration

Collaboration Across Teams

Collection Editor

Collection Generation and Sync

Collection Recovery

Collection Viewer

Collective Intelligence

Command Line Interface

Command Line Interface (CLI)

Commenting & Annotations

Common API Patterns

Common Integratin Patterns

Community Creators

Community Discussions

Community Manager

Compare Versions

Composable Templates

Composite Adapter

Composition Checks

Compositions

Comprehensive Matching

Comprehensive Reporting and Analytics

Concurrent API users

Conditional Caching

Configurable Policies

Configuring Error Handlers

Conformance Validation

Connect Data

Connect to SAAS Applications

Connectivity API

Connector Builder

Connector Development Kit (Sdk)

Connectors

Consumer Tags

Container Packaging

Contextname Keystone Attribute

Continuous Communication Between Mulesoft and Agentforce

Continuous Software Updates

Contracts

Copilot

Copilots

Cost Analytics

Cost Management

Cost per Additional API Developer Portal

Cost per Additional Published API

Cost per Dcgw Control Plane

CPU Resources

Create Any API With Asyncapi

Create Any API With Graphql

Create Any API With Oas

Create Any API With Raml

Create Capability with AI

Credital Management

Curated Set of API Topics

Custom App Builder With AI

Custom Components

Custom Connector Creation

Custom Connector Tooling

Custom Connectors

Custom Data Retention

Custom Domain

Custom Domains

Custom firewall rules

Custom Security Policies

Custom Test Records

Custom Webhooks

Customer Hosted

Customer Success

Customer Success Resources

Customer-Facing Workflows

Customizable Executions

Customizable In-App Marketplace (Optional)

Customized Error Settings

Customized Polling Time

Cyclr API Access for Custom UI

Dashboards

Data Access Layer

Data Encryption

Data Formats

Data Hub

Data Immutability

Data Integration

Data Management

Data Messages

Data Modifiers

Data Observability

Data on Demand/Proxy API

Data Orchestration

Data processing agreement

Data Quality

Data Recovery

Data Residency

Data Residency for Regional Compliance

Data Retention

Data Sanitization

Data Storage

Data Synchronization

Data Validation

Data Visualization

Data-As-A-Service

Database API Generation

Database connectors

Databases

Dcgw Bandwidth Cost

Dcgw Control Plane Limits

DDoS protection

Dead Letter Queue Availability

Declarative Data Processing

Decrease Mean-Time-To-Resolution

Dedicated Account Manager

Dedicated Cloud Gateways (DCGW)

Dedicated Customer Success Manager

Dedicated Integration Engineer

Dedicated Project Team

Dedicated Slack Channel

Dedicated Tech Support

Dedicated VPC

Define Governance Rules

Deploy GraphQL APIs

Deploy in AWS

Deploy in Azure

Deploy in GCP

Deploy Integrations

Deploy Runtimes on Amazon Web Services (AWS)

Deploy Runtimes on Google Cloud Platform

Deploy Runtimes on Microsoft Azure

Deploy Runtimes on Red Hat Openshift

Deployment Control

Deployment in Your VPC

Deployment of Capability to Istio Service Mesh

Design Suggestions

Design Time Error Handling

Desktop and Web Appside Extension (vs Code)

Develop Integration

Developer Portals

Development Workspaces

Devleopment

Diagramming

Distributed Tracing

Docker

DockerHub Integration

Documentation

Domain Capture

Domain-Driven Design

Domains

Drafts

Dynamic Field Mapping

Edge Security

Edi

EDI Events

EDI Management

EDIFACT

Egress API Proxy

Element-Level Roles

Email Marketing Software

Email Only

Email Support

Email Support During Your Trial

Email Tracking Software

Email, Zendesk, Slack, and Other Channels Available

Embedded Automation Designer

Embedded Bundle

Embedded Integration Templates

Embedded Ipaas

Embedded Marketplace UI

Embedded Workflow Builder

Embedding Recipes

End-Customer Cloud Deployment

End-Customer On-Premise

End-To-End Monitoring

Enhanced Support

Enterprise Apps

Environment Contexts and Names

Environment Editor

Environment Viewer

Environment-Level Applications

Error Events to Server Function Triggers

Error Handling

Even Tstreaming

Event Handlers

Event Management

Event Streams

Event-Driven Federated Subscriptions (EDFS)

Everything in Cloud Plus

Evolve GraphQL APIs

Expert SQL Support

Expose Any API as an Mcp Server

Expose Data From Third Party Applications to Agentforce

Extensive Connector Library

Fail-Safe Mechanisms

Fair Use Quota Policy

Feature Flags

features

FedRAMP

Feedback Loops

FHIR standards

Field & entity level

Field Usage Statistics

File Management System

Filter Data Formats

Filters & Paths

Fine-Grained Admin Permissions

Flexible API Gateways

Flood Protection Settings

Flowcharts

Folder Permissions

Formatter

Formatter With AI

Free Chatbot Builder

Free Landing Page Builder

Free Live Chat Software

Free Meeting Scheduler App

Free Online Form Builder

Free Web Hosting

Free Website Builder

FTP/Secure FTP

Fully Managed Authentication

Function Code Copying

Function Invocation via UI

Function Lifecycle States

Function Owners and States

Function Replication

Function Replication Now Includes Schemas

GDPR Compliance

Generate Code Examples

Generate Documentation

Generate Functions

Generate Openapi

Generate Schema

Generic Approach

Geographic Location

Git-Based Workflow

Git-Ops

Github Copilot

GitHub Integration

Gitlab Support

Global Edge network

Global Routing

Global Variables

Globally Distributed Architecture

Golden Record

Govern GraphQL APIs

Governance

Governance and Access Controls

Graph Access Control

Graphical Integration Designer

GraphQL Adapter

Graphql API

GraphQL API endpoints

GraphQL backend

Graphql CLI

Graphql Client

GraphQL Clients

Graphql Federation

Graphql Gateway

Graphql Router

GraphQL SDKs

Graphql Subscriptions

gRPC Adapter

gRPC API

Grpc Client

Guided Recommendations

HIPAA

HIPAA compliance

HIPPA

HL7

Host on Any Kubernetes

HTTP Adapter

HTTP Client

Hybrid and Multi-Cloud Support

Hybrid API Gateway Control Plane Costs

Hybrid API Gateway Control Plane Limits

Hybrid API Gateways

Hybrid deployment

Hyperscale Log Management

Immutable builds & build URLs

Implementation

Improved Search for API Functions

Improving Server Function Wakeup Speed

In-App Support

Independent subgraph development

Ingest Openapi

Insights

Integrate GraphQL APIs

Integrated With Git

Integration Configuration

Integration Deployment

Integration Development Kit (Idk)

Integration Flows

Integration Hub

Integration Management

Integration Marketplace

Integration Monitoring

Integration Releases

Integration Solutioning

Integration Support

Integration Templates

Integration With Third-Party Monitoring and Observability Solutions

Integrations

Intelligent Document Processing

Intelligent geo routing

IntelliJ Integration

Intellisense

Internal Client Authentication

Internal Client Authorization

Internal Developer Portals

Internal Quota Management

Internal Rate Limitation

Internal Workspaces

Internal Workspaces (Private)

Interoperability

Inventory of APIs

Invoke Agentforce

iPaaS

ISO 27001

ISO 27001 Compliant

Istio Integration

Java Libraries

Jdbc

JDBC Adapter

Jms

Jobs

Join Data Formats

JSON Support

JSON-RPC Adapter

Kafka Adapter

Kafka Consumer

Kafka Producer

Kubernetes

Kubernetes Deployment

Lead Management Software

Limited to One Region per Control Plane

Live API Docs

Live Chat

Live Preview

Live Workshops

LLMs

Local development

Log Retention

Log Streaming

Logging

Logs

Logs Streaming via API

Low Code Apps

Low-Code

Low-Code Integration Designer

Lunar Interceptor

Lunar Proxy

Magic UI Configuration With Canopy

Manage Capability Ingress with kgateway

Manage GraphQL APIs

Manage Integrations

Managed Authentication

Managed Library

Managed Private Cloud

Managed Service

Management API

Manual Tasks

Map Data Formats

Market Analytics

Marketing Analytics

Master Data Management (MDM)

Max Concurrent Processes

Max Integration Frequency

Maximum Number of API Developer Portals

Maximum Number of Published Apisservice Catalog

MCP Adapter

MCP Gateway

Merlin Build

Message Broker

Message Brokers

Metrics

Mews Integration

Microservices

MLLP

Mobile Optimization

Mock Server Editor

Mock Server Viewer

Mock Servers

Model Choices as Discriminate Unions

Model Data as Data

Model Data Streams

Model Optionality

Model Tabular Data

Model Usage Statistics

Model-Driven

Monitor Cluster Status

Monitor Editor

Monitor Viewer

Monitoring

Mqtt

Mqtt Client

Multi-Environment

Multi-Factor Authentication

Multi-Partner Workspaces

Multi-Protocol Support

Multi-Region Deployment

Multi-repo CI/CD

Multi-Source Document Support

Multi-Tenancy

Multi-Tenancy for Applications

Multi-Tenancy for Workers

Multicloud Runtime

Native Apache Camel Integration

Native Connector Build

Natural Language Requirements

Nested aggregations

Nested filtering

Nested pagination

Nested sorting

Network API Generation

Network Management

Network Observability

Network Orchestration

Network Resources

New Tixr API Operations

Newman CLI

Next Generation Security

No Code Changes

No Log Retention

No-Code

Node Improvements

Normalize Data Formats

Number of Included API Developer Portals

Number of Included Governed Services

Number of Included Published APIs

Number of Integration Flows

Number of Regions

Number of supergraph developers

Number of Users

Oas Training Hosturl Improvements

OAuth

Observability

Observability API

Observe in Postman

Observe integrations

Odbc

ODBC Adapter

On-Premise

On-Premises Integration Agent

Onboarding

Onboarding Fee

Open Source

OpenAPI Adapter

OpenID Connect (OIDC)

OpenTelemetry

Opentelemetry Support

Operations

Option for Dedicated Cluster

Orchestrate Deployments

Orchestration

Orchestrations

Original Equipment Manufacturer (OEM)

Outline-Based Editing

Owner Access

Package Capability as Docker Image

Package Library

Partner (External)

Partner Editor

Partner Manager

Partner Portal

Partner Viewer

Pattern Matching

Pay-Per-Task Billing

PCI

People Tasks

Persisted Operations

Persistent Data Storage

Personalized Data Masking

Personalized Encryption

Plugin System

Policies

Policy Enforcement.

Polling Frequency

Polling Time

Polyapi Integration With Zoom

Portals

Postman API Supportaudit Logs

Postman CLI

Postman Interceptor

Postman Proxy

Postman Public Docs

Postman Vault

Pre-built Connectors

Pre-built Security Policies

Pre-built UI

Prebuilt API Fragments

Prebuilt Connectors

Prebuilt Examples

Prebuilt Templates

Premier Support

Premium Applications

Price per Additional Transaction

Prioritized API Queuing

Priority Email Support

Priority Support

Private API Documentation

Private API Network

Private APIs

Private/Internal-only

PrivateLink/Private

Process Automation

Process Data

Process Insights

Production Tenants

Production Workspaces

Production-Grade Ready

Professional Services

Professional Services Available

Programmatically Control Runtimes

Programmatically Monitor Runtimes

Project Glide Support for Python

Public API Documentation

Public API Function Replication

Public API Network

Pull-Request-Based Schema Workflows

Python Snippets in Polyapi

Quality

Query Plan

Quota Management

RAM Resources

RBAC

Real-Time Controls

Real-Time Execution Monitoring

Real-Time Insights

Real-Time Integrations

Real-Time Monitoring

Real-Time Notifications

Red-Badge Engineers

Regional Hosting

Regression-Tested Integrations

Regular Progress Calls

Relay API

Reliability

Reporting

Reporting & Analytics

Resource Catalog

Resource Quota

Responsive Experiences

REST API

Restful API

Results Tracker

Reusable API Fragments

Reusable Schema Models in Node

Role-Based Access

Role-Based Access Control

Role-Based Access Control (Rbac)

Roles & Permissions

Run GraphQL APIs

Runtime Monitoring

Runtime Recovery

SA/Advisory Support

Sales Email Templates

Salesforce Marketing Cloud Workflows

Saml

Saml Single Sign-on (SSO)

Saml-Based SSO

Samples

Scalability and Performance

Scale API Portals

Scale GraphQL APIs

Scale-to-Zero

Scheduled Tasks

Schema Change Notifications

Schema changelog

Schema Contracts

Schema Injection for Smarter Code Suggestions

Schema Management and Reusability

Schema References and Visibility

Schema Registry

Schema Usage Reporting

SDK Embedding

Search

Seats

Secret Scanning

Secrets Vault

Secure

Secure Capability with OPA

Secure Integrations

Security

Security and Governance

Self-Healing

Self-Hosted

Self-hosting with

Self-Managed

Self-Managed API Gateway

Semantic Data Formatting

Semantic Data Validation

Sensitive Information Detection

Sequence Diagrams

Serverless API Gateway Contol Plane Costs

Serverless API Gateway Control Plane Limits

Serverless API Gateways

Service Catalog

Service Connect

Service Level Agreement (SLA)

Service Mesh

Service Mesh Management

Service Side Scripting

Sfx Execution Key (Ts)

Shared App Connections

Shared Cluster

Shared Metrics

Shared Platform

Shared Zaps

Singer Adapter

Single & Multi-Partner Workspaces

Single Partner Workspaces

Single Sign-On (SSO)

Sla

Slack Hotline

Slack Teams Onboarding

Smarter Python Integrations

SOAP to REST

SOC 1

SOC 2

SOC 2 Reports

SOC 3

SOC2 Type 2

socket.io Client

Software Developer Kit (SDK)

Source of Truth

SSH/On-Prem Connectivity

SSO

SSO, Scim, & Saml

Staging Environment

Standards Control Groups

Starter Task Credit

StateRAMP

Static IP

Static IP for On-Prem

Step-By-Step Executions

Steps

Steps Per Automation

Storage Management

Storage Resources

Studio

Super Admin

Super Admin Role

Supergraph Explorer

Supergraph Registry

Support

Support Channel

Support Channels

Switch Environments

Syncing & Polling

System Agnostic

System Health Status Page

System Recovery

Talend Adapter

Task Automation

Team-Level Roles

Technical Account Manager

Technical Support and Customer Success

Test Data Storage

Testing

Ticketing System

Tooltips for Canopy Applications

Tooltips, Date Pickers, Smarter 404s

Trace Viewer

Traces Retention time

Tracing

TRADACOMS

Traffic Control

Traffic Patterns

Training

Training and Support

Transactions

Transactions per Month

Transform Data

Tray Academy

Tray Advantage

Tray Advantage Plus

Tray Community

Trigger API

tRPC Adapter

Two-Factor Authentication

Type Safety

UI Customization

Understand Health of Your Application Network

Unified View of Applications

Unified View of Runtime

Unique Variable IDs Introduced

Universal Visibility

Unlimited API Calls

Unlimited API Creation

Unlimited API Volume

Unlimited Collaborators

Unlimited Component Repositories

Unlimited Connectors

Unlimited Data Records

Unlimited Premium Apps

Unlimited Private & Public APIs

Unlimited Tenants

Unlimited Workflows

Unlimited Zaps

Updates

Usage

Usage Insights

Use Cases

User Groups

User Interfaces

User Level Reporting & Analytics

User Management

User Management, Access Control, and Governance

User Provisioning (Scim)

Users

v3 graphql-engine

Variables and Triggers in Activity History

Vector Databases

Versions

View Syntax Errors

Visibility

Visual Editor

Visual Mapping

VPC peering

vs Code Integration

Vscode Integration

VSCode Plugin

Web Services

Webhook Limit

Webhook Triggering Params Parsing

Webhooks

Websocket Client

White Label Integrations

White Labeling

White-Label

Whiteglove Support

Whitelabeling

Workflow Bots

Workflow Canvas

Workflow Engine

Workflow Library

Workflows

Working With Data

Workspace Admin

Workspace Editor

Workspace Themes

Workspace Updates

Workspace Viewer

Workspace-Level Roles

Workspaces

WSDL

X12

XML Support

Zapier Agents

Zapier Canvas

Zapier Chatbots

Zapier Interfaces

Zapier Mcp

Zapier Tables

Zero cold-start


Last modified January 2, 2026: update (871c07bef)