API Manager Documentation 4.2.0 Gateway API v2
4.2.0
  • Show all
Initializing the Documentation Search ...
  • Home
  • Get Started
  • Design APIs
  • Deploy and Publish APIs
  • Consume APIs
  • Integrate
  • Streaming
  • Analytics
  • Observe
  • Reference
  • Administer
  • Install and Setup
  • Tutorials

Report Issues
wso2/docs-apim
  • Documentation
    • Overview
    • Key Concepts
    • Architecture
      • API Management
      • Integration
      • Streaming
    • About this Release
    • Design APIs Overview
        • Create a REST API
        • Create a REST API from an OpenAPI Definition
        • Expose a SOAP Service as a REST API
        • Generate REST API from SOAP Backend
        • Test a REST API
      • GraphQL APIs
        • Streaming API Overview
        • Create a WebSocket API
        • Create a WebSub/WebHook API
        • Create a SSE API
        • Create a Streaming API from an AsyncAPI Definition
        • Test a WebSub/WebHook API
      • Create an API From a Service
    • Create API Revisions
    • Add Custom Properties to APIs
    • Change the Thumbnail of an API
      • Overview
        • With API Gateway
        • With Choreo Connect
      • Existing Backend Implementation as a Prototype API
      • API Product Overview
      • Create an API Product
      • Endpoint Types
        • Secure Endpoint with Basic Auth
        • Secure Endpoint with Digest Auth
        • Secure Endpoint with OAuth 2.0
      • High Availability for Endpoints
        • Endpoint Timeouts
        • Endpoint Suspension
        • Prevent API Suspension
      • Manage Certificates
      • API Lifecycle
      • Customize API Life Cycle
      • Create a New API Version
      • Deprecate the Old Version
      • Backward Compatibility
      • Enable Notifications
      • Add API Documentation
      • View Generated Documentation
      • Comment on an API via the Publisher
      • Enable Social Media Interaction
      • Overview
      • Attach Policies
      • Create a Policy
        • Add Dynamic Endpoints
        • Remove Specific Request Headers From Response
        • Pass a Custom Authorization Token to the Backend
        • URL Mapping
        • Disable Message Chunking
        • Transform API Message Payload
        • Add a Non-Blocking Send Operation
        • Add a Class Mediator
        • Configure Message Builders and Formatters
        • Overview
        • Call Interceptor Service
        • Create a Custom Policy
      • Revoke One Time Tokens Policy
        • Overview
        • Secure APIs using OAuth2 Access Tokens
        • Secure APIs using API Keys
        • Secure APIs using Mutual SSL
        • Secure APIs using Basic Authentication
        • Secure APIs using Certificate Bound Access Token
        • Federating OAuth Applications
        • Disable Security
        • Overview
        • Role-Based Access Control using Scopes
        • Role-Based Access Control using XACML
        • Publisher Portal in Read Only Mode
      • Secure APIs by Auditing API Definitions
        • JSON Schema Validator
          • JWT Access Tokens
          • Role-Based Access Control with OAuth Scopes
          • Scope Whitelisting
          • Overview
          • Password Grant
          • Client Credentials Grant
          • Authorization Code Grant
          • Refresh Token Grant
          • JWT Grant
          • SAML Extension Grant
          • Kerberos OAuth2 Grant
          • NTLM Grant
        • Token Revocation
        • Token Expiration
        • Token Persistence
        • Encrypting OAuth2 Tokens
        • Hashing OAuth Keys
        • Provisioning Out-of-Band OAuth Clients
        • Securing OAuth Token with HMAC Validation
        • Bot Detection
        • Gateway Threat Protectors
        • Regular Expression Threat Protection
        • JSON Threat Protection
        • XML Threat Protection
        • Obtain User Profile Information with OpenID Connect
        • Overview
        • Custom OPA Policy for Regualr Gateway
        • Custom OPA Policy for Choreo Connect
      • Throttling Use-Cases
      • Add New Throttling Policies
      • Set Throttling Limits
      • Access Control
      • Enforce Throttling and Resource Access Policies
      • Set Maximum Backend Throughput Limits
      • Rate Limiting for Streaming APIs
        • Overview
        • Query Depth Limit
        • Query Complexity Limit
        • Custom Rate Limiting
        • Distributed Burst Control, Backend Rate Limiting for API Gateway Cluster
      • Monetize an API
      • Enable Publisher Access Control
      • Control API Visibility and Subscription Availability in the Developer Portal
      • Enable CORS for APIs
      • Add an API State Change Workflow
      • Block Subscription to an API
      • Validate API Definitions with Linters
      • Deploy APIs in the API Gateway vs Choreo Connect
        • Deploy an API
        • Expose APIs via Custom Hostnames
        • Deploy Through Multiple API Gateways
        • Overview of the WSO2 API Gateway
        • Response Caching
          • Regular Expression Threat Protection
          • JSON Threat Protection
          • XML Threat Protection
        • Pass End User Attributes to the Backend
        • Gateway Environments
        • Scale the Gateway
          • API Gateways with Dedicated Backends
          • Mutual SSL Between API Gateway and Backend
          • Storing Custom Synapse Artifacts in the Gateway
        • Choreo Connect Overview
        • Supported Features
        • Quick Start Guide
            • Overview
            • Event Hub
            • Rate Limiting
            • Revoked Tokens
            • Third Party Key Manager
          • As a Standalone Gateway
          • Subscription Validation
          • Choreo Connect With Tenants
          • Supported Template Patterns
          • Choreo Connect Analytics
          • REST API
          • SOAP API
          • REST API from a SOAP Endpoint
          • WebSocket API
          • GraphQL API
          • Expose via Custom Hostnames - vHosts
            • Deploy as an Immutable Gateway
          • REST API with a Mock Implementation
            • Overview
            • Use an Internal Key
            • Use an Access Token
            • Use an API Key
            • Use Mutual SSL
            • Use an Enforcer Test Key
            • Configure an External Key Manager
            • Use a Custom Authorization Header
            • Reject Revoked Tokens
            • Disable Security
            • Scope Validation
            • Subscription Validation
            • Custom Claims Mapping
            • Open Policy Agent (OPA) Validation
            • Component Certificates
            • Backend Certificates
            • mTLS Between Choreo Connect and Backend
          • Enable CORS
          • Pass End User Attributes to the Backend
          • Configuration Overview
            • Overview
            • Adapter
            • Enforcer
            • Router
            • Adapter
            • Enforcer
            • Router
            • Control Plane
            • Analytics
            • Tracing
          • Overview
          • Installation Prerequisites
            • With WSO2 API Manager as a Control Plane
            • As a Standalone Gateway
            • With WSO2 API Manager as a Control Plane
            • As a Standalone Gateway
            • With WSO2 API Manager as a Control Plane
            • As a Standalone Gateway
          • Endpoint Types
          • Define Endpoints in an OpenAPI Definition
          • Load Balanced Endpoints
          • Failover Endpoints
          • Override Endpoint Information
          • Define a Backend Security Scheme
            • Retry Policies
            • Timeouts
            • Circuit Breakers
          • Add Custom Filters
          • Request Payload Passing
          • Enable Distributed Rate Limiting
            • Overview
              • Overview
              • Request Flow Interceptor
              • Response Flow Interceptor
              • Interceptor Context and Invocation Context
              • Sample Interceptor Services
            • Define Interceptors in an OpenAPI Definition
          • API Policies
          • Configure Choreo Connect with Consul
          • Service Discovery
          • Service Mesh
          • Service Mesh in Kubernetes
        • Service Mesh Integration
          • Distributed Tracing
          • Prometheus Metric Support
          • Configure Analytics with Choreo Connect
          • Publish Custom Attributes with Analytics
        • Git Integration
        • Data Compression
        • Configure Multiple Gateways with Choreo Connect
        • File Upload via Multipart Requests
        • HTTP 2.0
        • Token Caching
        • Production Deployment Guideline
          • Overview
          • Router with One CPU
          • Router with Two CPU
        • Migrate from Ballerina API Microgateway to Choreo Connect
          • Enable Debug Logs
          • Error Handling
          • Enforcer Admin API
          • Debug Memory Issues
        • x-forward-for (XFF)
        • Update Choreo Connect
        • Frequently Asked Questions (FAQs)
      • Publish an API
      • Add a Third-party API
      • Publish to Multiple External API Developer Portals
      • Import APIs From AWS API-Gateway to WSO2 API-M
    • Consume APIs - Overview
      • Search
      • Create Application
        • Application Keys
          • Password Grant
          • Client Credentials Grant
          • JWT Grant
          • Kerberos OAuth2 Grant
          • Refresh Token Grant
          • Authorization Code Grant
          • SAML Extension Grant
          • NTLM Grant
        • Overview of Access Tokens
        • Access Tokens Per Device
        • Change the Default Token Expiration Time
        • Revoke OAuth2 Application
      • Share Applications
        • Add Custom Attributes to Applications
        • Change the Owner of an Application
        • Add an Application Creation Workflow
        • Add an Application Key Generation Workflow
      • Subscribe to an API
        • Add an API Subscription Workflow
        • Add an API Subscription Tier Update Workflow
        • Add an API Subscription Deletion Workflow
        • Test a REST API
        • Test a GraphQL API
        • Add Additional Headers to Test a REST API
      • SOAP Client
      • Postman
      • Interact with the Community
      • Generate SDKs in Developer Portal
      • Write a Client Application Using the SDK
      • Recover Password
      • Change Password
    • Integration Overview
    • Integration Concepts
    • API-led Integration
      • Message Routing and Transformation
      • Service Orchestration
      • Asynchronous Message Processing
      • SaaS and B2B Connectivity
      • Data Integration
      • Protocol Switching
      • File Processing
      • Periodic Execution of Integration Processes
      • Develop Integration Solutions
        • Quick Tour - WSO2 Integration Studio
        • Install WSO2 Integration Studio
        • Work with WSO2 Integration Studio
        • Troubleshooting WSO2 Integration Studio
      • Develop Your First Integation
      • Publish Integrations to the API Manager
        • Create an Integration Project
        • Create Data Service Configs
        • Create Datasource Configs
        • Import Projects
        • Export Projects
        • Create Docker Exporter
        • Create Kubernetes Exporter
        • Importing Artifacts
        • Create a REST API
        • Create a Proxy Service
        • Create an Inbound Endpoint
        • Create Scheduled Tasks
        • Create a Message Store
        • Create a Message Processor
        • Create an Endpoint
        • Create an Endpoint Template
        • Create a Sequence Template
        • Create a Reusable Sequence
        • Create a Registry Resource
        • Create Local Registry Entries
        • Create a Datasource
        • Create a Data Service
        • Create a Data Service Input Validator
        • Adding Connectors
        • Generate Service Catalog Metadata Artifacts
        • Create a Custom Inbound Endpoint
        • Create a Custom Mediator
        • Create a Synapse Handler
        • Create a New Connector
        • Customizing Task Scheduling
      • Exporting Artifacts
        • Use Docker Secrets in Synapse Configurations
        • Use Kubernetes Secrets in Synapse Configurations
        • Apply Security to a REST API
        • Apply Security to a Proxy Service
        • Apply Security to a Data Service
      • Package Artifacts
      • Deploy Artifacts
        • Use the Embedded Micro Integrator
        • Use a Remote Micro Integrator
        • Hot Deploying Artifacts
        • Create a Unit Test Suite
        • Generate Docker Images
        • Mediation Debugging
        • Use Wire Logs
        • Monitor Service-Level Logs
        • Monitor API-Level Logs
        • Endpoint Trace
        • Inject Parameters
        • Change the Endpoint of a Deployed Service
        • Swagger Documents
        • Extend Role-based Data Filtering
        • Dynamic User Authentication
        • Route Based on Message Headers
        • Route Based on Message Payload
        • Split Messages and Aggregating Responses
        • Convert JSON Messages to SOAP
        • Convert POX Messages to JSON
        • JMS to HTTP/S
        • HTTP/S to JMS
        • FTP Listener to Mail Sender
        • HTTP to FIX
        • FIX to HTTP
        • FIX to AMQP
        • FIX Versions
        • TCP to HTTP/S
        • UDP to HTTP/S
        • HTTP to MSMQ
        • Use VFS for File Transferring
        • Access a Windows Share Using VFS
        • Send and Receive Emails
        • Expose an RDBMS datasource
          • CSV datasource
          • Mongo datasource
          • Carbon datasource
        • Expose Data in JSON Format
        • Use an OData Service
        • Use Nested Data Queries
        • Batch Requesting
        • Invoke Multiple Operations as a Request Box
        • Use Distributed Transactions in Data Services
        • Validate Data Input
        • Swagger Documents of RESTful Data Services
          • Point to Point
          • Publish/Subscribe
            • Message Store and Message Processor
            • Retry failed messages with a delay
            • Requeue a message preserving the order
            • Publish messages to DLX
          • Dual Channel
          • Consume JMS Messages
          • Produce JMS Messages
          • Consume and Produce JMS Messages
          • Dual Channel HTTP-to-JMS
          • Quad Channel JMS-to-JMS
          • Guaranteed Delivery with Failover
          • Publish and Subscribe with JMS
          • Shared Topic Subscription
          • Detect Repeatedly Redelivered Messages
          • Specify Delivery Delay on Messages
          • Use a Simple REST API
          • Set Query Parameters on Outgoing Messages
          • Expose a SOAP Endpoint as a RESTful API
          • Expose Non-HTTP Services as RESTful APIs
          • Handle Non-Matching Resources
          • Handle HTTP Status Codes
          • Transform Content Types
          • Secure a REST API
          • Publish a Custom Swagger Document
          • Special Cases
          • Use a Simple Proxy Service
          • Publish a Custom WSDL
          • Expose a Proxy Service via Inbound Endpoints
          • Secure a Proxy Service
          • JMS Inbound Endpoint
          • File Inbound Endpoint
          • HTTP Inbound Endpoint
          • HTTPS Inbound Endpoint
          • HL7 Inbound Endpoint
          • MQTT Inbound Endpoint
          • RabbitMQ Inbound Endpoint
          • Kafka Inbound Endpoint
          • Secured WebSocket Inbound Endpoint
          • Use Inbound Endpoints with Registry
          • Task Scheduling Using a Simple Trigger
          • Inject Messages to a RESTful Endpoint
        • Local Registry Entries
          • Use Sequence Templates
          • Use Endpoint Templates
          • Introduction to Message Stores and Processors
          • JDBC Message Store
          • JMS Message Store
          • RabbitMQ Message Store
          • Message Sampling Processor
          • Message Forwarding Processor
          • Secure the Message Forwarding Processor
          • Load Balancing with Message Forwarding Processor
          • Address Endpoint
          • Failover Endpoints
          • HTTP Endpoint
          • WebSocket Endpoint
          • WSDL Endpoint
          • Load Balance Endpoint
            • Static List of Recepients
            • Dynamic List of Recepients
            • Dynamic List of Recepients with Aggregated Responses
          • Reuse Endpoints
          • Endpoint Error Handling
          • MTOM and SwA Optimizations
          • Break Complex Flows into Multiple Sequences
          • Use Fault Sequences
          • Reuse Sequences
        • Use the TCP Transport
        • Use the FIX Transport
        • Use the MQTT Transport
          • Mediate HL7 Messages
          • Acknowledge HL7 Messages
          • Use HL7 Messages with File Systems
      • Work with Transactions
      • JSON Examples
      • Integrate MI with SI
    • Streaming Overview
    • Streaming Key Concepts
      • Streaming Integrator Usecase Overview
        • Streaming API Overview
        • Create a WebSocket API
        • Create a WebSub/WebHook API
        • Create a SSE API
        • Create a Streaming API from an AsyncAPI Definition
        • Test a WebSub/WebHook Streaming API
      • Extract Data from static Sources in Real Time
      • Receive Data in Transit
      • Load and Writing Data
      • Publish Data
        • Stream Processing Overview
        • Cleanse Data
        • Transform Data
        • Enrich Data
        • Summarize Data
        • Correlate Data
      • Handle Errors
      • Perform ETL Operations
      • Trigger Integration Flows
      • Expose a Stream as a Managed API
      • Develop Streaming Integrator Solutions
        • Streaming Integrator Tooling Overview
        • Work with the Design View
        • Work with the AsyncAPI View
      • Create Siddhi Applications
      • Install Siddhi Extensions
      • Test Siddhi Applications
      • Deploy Siddhi Applications
      • Export Siddhi Applications
        • Overview
        • Step 1 - Download Streaming Integrator and Dependencies
        • Step 2 - Create the Siddhi Application
        • Step 3 - Deploy the Siddhi Application
        • Step 4 - Run the Siddhi Application
        • Step 5 - Update the Siddhi Application
        • Step 6 - Handle Errors
        • Step 7 - Monitor Statistics
        • REST API Guide Overview
        • Siddhi Application Management APIs
        • Permission APIs
        • Business Rules APIs
        • Store APIs
        • Healthcheck APIs
        • HTTP Status Codes
    • Migrating from WSO2 SP
        • Capture MySQL Inserts via CDC
        • Capture MySQL Inserts and Updates via CDC Polling Mode
        • Publish and Receive CSV Events via Files
        • Receive Events via File
        • Text Mapping with In-memory Transport
        • Publish HTTP Requests, Receive Responses, and Processe Them
        • Consume Messages from IBM Message Queues
        • Receive Events via HTTP Transport
        • Receive XML Events via Email
        • Receive Messages from a Google Pub/Sub Topic
        • Receive ER7 Events via HL7
        • Receive Custom XML Messages via HL7
        • Receive XML Events via HTTP
        • Receive Custom XML Events via HTTP
        • Receive JSON Events via HTTP
        • Receive Custom JSON Events via HTTP
        • Receive JSON Events via JMS
        • Receive Key Value Events via JMS
        • Receive Binary Events via Kafka
        • Receive Custom Text Events via Kafka
        • Receive XML events via MQTT
        • Receive Prometheus Metrics
        • Receive JSON Events via RabbitMQ
        • Receive JSON Events via TCP
        • Receive Binary Events via TCP
        • Receive Custom Text Events via TCP
        • Receive Text Events via TCP
        • Receive XML Events via Websocket
        • Receive Custom Key Value Events via SNMP
        • Receive Data via TCP and Preprocessing
        • Receive Email Alerts
        • Publish Aggregated Events to the Amazon AWS S3 Bucket
        • Publish and Receive CSV Events via Files
        • Publish Events to a GCS Bucket
        • Publish JSON Events to Files
        • Receive Events via Simulator and Persist in Cassandra Store'
        • Receive Events via Simulator and Persisting in a Store
        • Work with an influxDB Store
        • Receive Events and Persisting in MongoDB Store
        • Receive Events via Simulator and Persisting in RDBMS Store
        • Receive Events and Persisting Them in Redis Store
        • Receive Events via Simulator and Persisting in SOLR Store
        • Receive Data via TCP and Preprocessing'
        • Text Mapping with In-memory Transport
        • Consume Events from a Kafka Topic and Publish to Another Kafka Topic
        • Publish Text Events via Email
        • Publish Emails in XML Format
        • Publish Events to a Google Pub/Sub Topic
        • Publish ER7 Events via HL7
        • Publish XML messages via HL7
        • Publish JSON Events via HTTP
        • Send Custom JSON Events via HTTP
        • Publish XML Events via HTTP
        • Publish Custom XML Events via HTTP
        • Publish HTTP Events to to an OAuth-protected Endpoint
        • Publish HTTP Events to an OAuth-protected Endpoint while Using a Refresh Token Grant Type
        • Publish HTTP Events via an OAuth-protected Endpoint
        • Publish HTTP Events to an OAuth-protected Endpoint
        • Publish HTTP Events to an OAuth-protected Endpoint without an Access Token
        • Publish XML Events via JMS
        • Publish Key-value events via JMS
        • Publish Custom Avro Events via Kafka
        • Publish JSON Events via Kafka
        • Publish Binary Events via Kafka
        • Publish Avro Events via Kafka
        • Publish XML Events via MQTT
        • Publish Consumed Events to Prometheus Metrics and Exposing them via HTTP
        • Publish XML Events via RabbitMQ
        • Publish JSON Events via TCP
        • Publish Text Events via TCP
        • Publish Binary Events via TCP
        • Publish XML Events via WebSocket
        • Send Custom Keyvalue Events via SNMP
        • Aggregate Data Incrementally
        • Receive Email Alerts
        • Receive and Publish Events in Custom CSV Format
        • Publish and Receive CSV Events via Files
        • Preprocess Data Received via TCP
        • Perform Streaming Learning Using a Clustree Model
        • Processe Geo Data
        • Count the Frequency of Values with BottomK
        • Calculate the Distance Between Two Locations
        • Extract Values from a String
        • Make Predictions via Hoeffding Classifier Model
        • Join Streaming Data with Stored Data in RDBMS
        • Insert and Access Data in a Map
        • Round up Amounts via the Math Function
        • Identify Event Patterns Based On Order of Event Arrival
        • Make Predictions via PMML Model
        • Send Custom JSON Events via HTTP
        • Publish Custom XML Events via HTTP
        • Publish Custom Avro Events via Kafka
        • Receive Custom XML Events via HTTP
        • Receive Custom JSON Events via HTTP
        • Receive Custom Text Events via Kafka
        • Receive Custom Text Events via TCP
        • Identify Sub-sequences in Input Sequences
        • Use Javascript Functions in Siddhi Applications
        • Make Predictions via a Streaming Perceptron Model
        • Use StreamingML Kmeans for Clustering
        • Make Predictions via a Regressor Model
        • Convert String Values to Lowercase
        • Receive Data via TCP and Preprocessing
        • Perform Regression Tasks via an Imported Tensorflow Model
        • Text Map with In-memory Transport
        • Convert Units
        • Calculate Aggregations Over Time'
        • Architecture
        • Getting Started Guide
        • Role-based Access Control
        • Alerts
        • ELK Based Analytics Installation Guide
        • Datadog Analytics Installation Guide
      • Publish Analytics Events to External Systems
      • Publish Custom Analytics Events Data
        • Setup
        • Access the Dashboard
        • Setup
        • Access the Dashboard
    • Observability Overview
        • Correlation Logs
        • HTTP Access Logs
        • Audit Logs
        • API Logs
        • OpenTracing
        • OpenTelemetry
        • JMX-Based Monitoring
        • Overview
        • Getting Started Guide - VM Deployment
        • Getting Started Guide - K8s Deployment
        • View Statistics
          • Configure Logs
          • Enable Logs for a Component
          • Monitor Logs
          • Monitor Correlation Logs
          • Monitor Audit Logs
          • OpenTelemetry
          • JMX Monitoring with JMX
          • SNMP Monitoring with SNMO
      • Getting Started
        • View General Statistics
        • View ETL Flow Statistics
      • Overview
        • Publisher API v4
        • Developer Portal API v3
        • Admin API v4
        • Gateway API v2
        • Service Catalog API v1
        • DevOps API v0
      • Advanced Configurations
      • Understand the New Configuration Model
      • API-M Config Catalog
      • MI Config Catalog
      • MI Dashboard Config Catalog
    • API Controller (APICTL)
    • API Kubernetes Operator
      • Connectors Overview
      • When to Use Connectors
      • Connector Usage Guidelines
      • Connector Developer Guidelines
        • Amazon DynamoDB Overview
        • Set up Amazon DynamoDB
        • Amazon DynamoDB Example
        • Amazon DynamoDB Reference
        • Amazon Lambda Overview
        • Set up Amazon Lambda
        • Amazon Lambda Example
        • Amazon Lambda Reference
        • AmazonS3 Overview
          • Set up Amazon S3
          • AmazonS3 Example
          • AmazonS3 Reference
          • Set up Amazon S3
          • AmazonS3 Example
          • AmazonS3 Reference
        • Amazon SQS Overview
        • Amazon SQS Example
        • Amazon SQS Reference
        • Amazon SQS Inbound Endpoint Example
          • 1.0.x
          • 1.1.x
        • BigQuery Overview
        • Set up the BigQuery Environment
        • BigQuery Example
        • BigQuery Reference
        • Ceridian Dayforce Overview
        • Set up the Ceridian Dayforce Connector
        • Ceridian Dayforce Example
          • Initializing
          • Employee
            • orgUnits
            • orgUnitDetails
            • listOfDocuments
            • documentDetails
            • employeeClockDeviceGroups
            • employeeCompensationSummary
            • employeeCourses
            • employeeEmploymentAgreements
            • employeeEmploymentStatuses
            • employeeEmploymentTypes
            • employeeHighlyCompensatedEmployees
            • employeeHRIncidents
            • employeeLaborDefaults
            • employeeOnboardingPolicies
            • employeeOrgInfo
            • employeePayAdjustmentCodeGroups
            • employeePayGradeRates
            • employeePerformanceRatings
            • employeeProperties
            • employeeSkills
            • employeeTrainingPrograms
            • employeeUnionMemberships
            • employeeWorkAssignments
            • employeeWorkContracts
            • employeeWorkContracts
            • employeeAddresses
            • employeeCANTaxes
            • employeeContacts
            • employeeDirectDeposits
            • employeeEmergencyContacts
            • employeeHealthandWellness
            • employeeMaritalStatuses
            • employeeUSTaxes
            • availability
            • employeePunches
            • employeeRawPunches
            • schedules
            • timeAwayFromWork
            • i9Order
            • jobPostings
            • reportMetadataForAListOfReports
            • reportMetadataForASpecificReport
            • reports
            • documentManagementSecurityGroups
            • employeeLocations
            • employeeManagers
            • employeeRoles
            • employeeSSOAccounts
            • employeeWorkAssignmentManagers
            • userPayAdjustmentCodeGroups
        • CSV Module
        • Database Event Listener Overview
        • Database Event Listener Example
        • Database Event Listener Reference
        • Documentum Overview
        • Documentum Example
        • Documentum Reference
        • Email Connector Overview
        • Email Connector Example
        • Email Connector Reference
        • Jira Connector Overview
        • Jira Connector Example
        • Jira Connector Reference
        • FHIR Overview
        • FHIR Example
        • FHIR Reference
        • File Connector Overview
          • File Connector Example
          • File Connector Reference
          • File Connector Example
          • File Connector Reference
        • Gmail Overview
        • Gmail Example
        • Gmail Reference
        • Google Firebase Overview
        • Set up Google Firebase
        • Google Firebase Example
        • Google Firebase Reference
        • Google PubSub Overview
        • Set up the Google PubSub Environment
        • Google PubSub Example
        • Google PubSub Reference
        • Google Spreadsheet Overview
        • Google Spreadsheet Example
        • Google Spreadsheet Reference
        • ISO8583 Overview
        • Set up ISO8583
        • ISO8583 Example
        • ISO8583 Reference
        • ISO8583 Inbound Endpoint Example
        • ISO8583 Inbound Endpoint Reference
        • Kafka Overview
        • Set up Kafka
        • Enable Security for Kafka
          • Kafka Example
          • Kafka Avro Message Example
          • Kafka Connector Reference
          • Kafka Example
          • Kafka Connector Reference
        • Kafka Inbound Endpoint Example
        • Kafka Inbound Endpoint Reference
        • LDAP Overview
        • Set up an LDAP Server
        • LDAP Example
        • LDAP Reference
        • Microsoft Azure Storage Overview
        • Set up Microsoft Azure Storage
          • Microsoft Azure Storage Example
          • Microsoft Azure Storage Reference
          • Microsoft Azure Storage Example
          • Microsoft Azure Storage Reference
        • MongoDB Connector Overview
        • MongoDB Connector Example
        • MongoDB Connector Reference
        • Redis Overview
        • Set up the Environment
        • Redis Example
          • Redis Connector Reference
          • Redis Connector Reference
          • Redis Connector Reference
          • Redis Connector Reference
        • Salesforce Overview
        • Salesforce Access Token Generation
        • Set up the PushTopic in Salesforce
          • Salesforce REST Connector Example
            • Salesforce REST Connector Reference
            • Salesforce REST Connector Reference
        • Salesforce Inbound Endpoint Example
        • Salesforce Inbound Endpoint Reference
        • Salesforce Bulk Configuration
        • Salesforce Bulk API Example
        • Salesforce Bulk API Reference
        • Salesforce Bulk API V2 Example
        • Salesforce Bulk API V2 Reference
        • Salesforce SOAP Connector Configuration
        • Salesforce SOAP Connector Example
        • Salesforce SOAP Connector Reference
        • ServiceNow Overview
        • Set up Servicenow
        • ServiceNow Example
        • ServiceNow Reference
        • SMPP Overview
        • Set up the SMPP Connector
        • SMPP Example
        • SMPP Reference
        • SMPP Inbound Endpoint Example
        • SMPP Inbound Endpoint Reference
        • Twitter Overview
        • Generate Credentials
        • Set up Integration Runtime
        • Twitter Example
        • Twitter Reference
        • Snowflake Connector Overview
        • Snowflake Connector Example
        • Snowflake Connector Reference
        • Utility Module Overview
        • Utility Module Reference
      • Streaming Integrator Connectors Overview
      • Downloading and Install Siddhi Connectors
      • Writing Custom Siddhi Extensions
      • Configure System Parameters for Siddhi Extensions
      • REST API Properties
      • Proxy Service Properties
        • About Mediators
        • Aggregate Mediators
        • Builder Mediator
        • Cache Mediator
        • Call Mediator
        • Call Template Mediator
        • Callout Mediator
        • Class Mediator
        • Clone Mediator
          • Data Mapper Mediator
          • Data Mapper Schema Specification
        • Data Service Call Mediator
        • DBLookup Mediator
        • DB Report Mediator
        • Drop Mediator
        • EJB Mediator
        • Enrich Mediator
        • Entitlement Mediator
        • FastXSLT Mediator
        • Fault Mediator
        • Filter Mediator
        • ForEach Mediator
        • Header Mediator
        • Iterate Mediator
        • JSON Transform Mediator
        • Log Mediator
        • Loopback Mediator
        • NTLM Mediator
        • OAuth Mediator
        • PayloadFactory Mediator
        • Property Mediator
        • Property Group Mediator
        • Respond Mediator
        • Script Mediator
        • Send Mediator
        • Sequence Mediator
        • Smooks Mediator
        • Store Mediator
        • Switch Mediator
        • Throttle Mediator
        • Transaction Mediator
        • URLRewrite Mediator
        • Validate Mediator
        • XQuery Mediator
        • XSLT Mediator
        • Generic Properties
        • HTTP Transport Properties
        • SOAP Headers
        • Axis2 Properties
        • Synapse Message Context Properties
        • Accessing Properties with XPath
      • Scheduled Task Properties
        • Endpoint Properties
        • About Inbound Endpoints
        • HTTP Inbound Endpoint
        • CXF WS RM Inbound Endpoint
        • HL7 Inbound Endpoint
        • Websocket Inbound Endpoint
        • File Inbound Endpoint
        • JMS Inbound Endpoint
        • Kafka Inbound Endpoint
        • RabbitMQ Inbound Endpoint
        • MQTT Inbound Endpoint
        • Custom Inbound Endpoint
        • About Message Stores and Processors
          • JMS Message Store
          • JDBC Message Store
          • RabbitMQ Message Store
          • Resequence Message Store
          • WSO2 MB Message Store
          • In Memory Message Store
          • Custom Message Store
          • Message Sampling Processor
          • Scheduled Message Forwarding Processor
          • Scheduled Failover Message Forwarding Processor
      • Templates
      • Endpoints
        • About Data Services
        • Elements of a Data Service
        • Query Parameters
        • Datasource Parameters
        • Input Validators
        • Namespaces
        • SQL/Data Types
        • Sample Queries
        • VFS Parameters
        • JMS Parameters
        • RabbitMQ Parameters
        • HL7 Parameters
        • FIX Parameters
        • MailTo Parameters
        • MQTT Parameters
        • Customize Secure Vault
        • Use Keystores
        • WS-Security Implementations
      • Vendor Specific Extensions
          • Extend Key Validation
          • Extend Scope Validation
          • Extend Key Manager
          • Write Custom Grant Types
          • Customize API Template
          • Write Custom Handlers
          • Invoke the API Manager from the BPEL Engine
          • Customize a Workflow Extension
          • Configure HTTP Redirection for Workflows
          • Configure Workflows for Tenants
          • Configure Workflows in a Cluster
          • Change the Default User Role in Workflows
          • Clean Up Workflow Tasks
          • Configure Single Sign On with SAML2
          • Configure External IDP Through Identity Server for SSO
          • Configure Identity Server as IDP for SSO
          • Multi Factor Authentication for Publisher and Developer Portals
          • Override the Developer Portal Theme
            • API Category based Grouping
            • Change Default View
          • Enable or Disabl API Detail Tabs
          • Override API Overview Page per API
          • Enable or Disable Rating
          • Enable or Disable Home Page
          • Enable or Disable Tag Cloud
          • Enable or Disable Footer
          • Enable or Disable Banner
          • Styling API Details Left Menu
          • Styling API Details Info Section
          • Styling the Logo and Header
          • Enable or Disabling Self Signup
          • Configure reCaptcha for Self-SignUp
        • Override the Publisher Portal Theme
        • Log in to the Developer Portal Using Social Media
        • Directing the Root Context to the Developer Portal
        • Customize User Signup in Developer Portal
        • Customize Login Pages for Developer Portal and Publisher
        • Customize the Developer Portal and Gateway URLs for Tenants
        • Add a User Signup Workflow
        • Add internationalization
        • Define Custom Linter Rules
        • Advanced UI Customization
      • Admin Services
      • Work with the Source Code
      • Java Documentation
      • WSO2 API-M Best Practices
    • Accessibility Compliance
      • Message Flow in the API Manager Gateway
      • Accessing API Manager by Multiple Devices Simultaneously
      • admin_Directory Structure of WSO2 Products
      • Error Handling
      • Error Handling in Micro Integrator
      • Capturing System Data in Error Situations
      • Troubleshooting in Production Environments
      • Cleaning Up Partially Created Keys
      • Configure XSLT Mediation with Xalan
      • Troubleshooting 'Registered callback does not match with the provided url' error
      • Troubleshooting JMS
      • Troubleshooting WebSocket APIs
    • FAQ
    • Administer Overview
      • Introduction to User Management
        • Manage User Roles
        • Manage Users
        • Manage Role Permissions
        • Manage Users for Admin Portal
      • Manage Users for Micro Integrator
      • Manage Users for the Streaming Integrator
      • Introduction to User Stores
        • API Manager
        • Micro Integrator
      • Write a Custom User Store Manager
      • Configure the Authorization Manager
      • Introduction to Multitenancy
      • Manage Tenants
      • Configure the Tenant Loading Policy
      • Configure Logs
      • Server Health
        • Micro Integrator Dashboard
        • Management API
        • Manage Log Growth
        • Masking Sensitive Information in Logs
      • Manage Dashboards
      • Overview
      • Configure WSO2 IS as a Key Manager
      • Configure Keycloak as a Key Manager
      • Configure Okta as a Key Manager
      • Configure Auth0 as a Key Manager
      • Configure PingFederate as A Key Manager
      • Configure ForgeRock as a Key Manager
      • Configure a Custom Key Manager
    • Advanced Configurations
    • Install and Setup Overview
      • Installation Prerequisites
        • Install API-M
        • Run API-M
        • Run API-M as a Linux Service
        • Run API-M as a Windows Service
        • Install MI
        • Run the MI Runtime
        • Run the MI as a Windows Service
        • Run the MI in Automation Mode
        • Install the MI Dashboard
        • Run the MI Dashboard
        • Run the MI Dashboard as a Windows Service
        • Install SI
        • Install Siddhi Extensions
        • Run SI
        • Run SI as a Windows Service
        • Run SI as a Linux Service
          • Install in Docker
          • Install in Kubernetes
      • Installation Options
        • Update WSO2 API Manager
          • Set up a Third-party Key Manager
          • Set up WSO2 Identity Server as a Key Manager
          • Overview
            • Change to MySQL
            • Change to MSSQL
            • Change to PostgreSQL
            • Change to Oracle
            • Change to MariaDB
            • Change to IBM DB2
            • Change to Oracle RAC
          • Manage Data Growth and Improving Performance
          • Configure the Proxy Server and the Load Balancer
          • Add a custom Proxy Path
            • Maintain Logins and Passwords
              • Customize Secure Vault
              • Set Passwords Using Environment Variables/System Properties
              • Work with Encrypted Passwords
              • Set Up ReCaptcha
              • Configure reCaptcha for Single Sign On
            • Configure Keystores in API Manager
              • Create a New Keystore
              • Renew a CA Signed Certificate
              • About Asymetric Cryptography
          • Enable HostName Verification
          • Enable Java Security Manager
          • General Data Protection Regulation (GDPR) for WSO2 API Manager
          • Configure Transport Level Security
          • User Account Management
          • Secure Web Portals
          • Introduction to User Stores
            • Configure Primary User Stores
            • Configure a JDBC User Store
            • Configure a Read-Write LDAP User Store
            • Configure a Read-Only LDAP User Store
            • Configure a Read-Write Active Directory User Store
          • Configure Identity Server As External IDP with OIDC
          • Configure Identity Server As External IDP with SAML
          • OKTA As An External IDP With OIDC
          • OKTA As An External IDP With SAML
          • Change the Default Transport
          • Configure Caching
          • Customize the Management Console
        • Update WSO2 Micro Integrator
          • Configure a User Store
            • MySQL Database
            • MSSQL Database
            • Oracle Database
            • PostgreSQL Database
            • IBM Database
          • Configure the File-Based Registry
            • Create New Keystores
            • Add SSL certificates to keystores
            • Renew a CA-signed Certificate
            • Configure Keystores
            • GDPR for the WSO2 Micro Integrator
            • About the Identity Anonymization Tool
            • Encrypt Secrets Using WSO2 Secure Vault
            • Use Hashicorp Secrets
            • Use Symmetric Encryption
          • Secure the Management API
            • Deploy RabbitMQ
            • Connect to RabbitMQ
            • Connect to ActiveMQ
            • Connect to Apache Artemis
            • Connect to HornetQ
            • Connect to IBM Websphere App Server
            • Connect to IBM WebSphere MQ
            • Connect to JBoss MQ
            • Connect to MSMQ
            • Connect to Swift MQ
            • Connect to TIBCO EMS
            • Connect to Weblogic
            • Connect to WSO2 MB
            • Connect to Multiple Brokers
          • Kafka
          • Azure Service Bus
        • Transports
        • Multi-HTTPS Transport
        • Message Builders and Formatters
        • Message Relay
        • Manage Configurations across Environments
          • Load Balancing
          • Configure a Proxy Server
          • Enable SSL Tunneling through Proxy Server
        • Time Stamp Conversion for RDBMS
        • Update WSO2 Streaming Integrator
        • Production Checklist
        • Performance Analysis Results
        • Configure Business Rules Deployment
        • Configure Data Sources
          • General Data Protection Regulations
          • Keystores
          • Protect Sensitive Data via the Secure Vault
        • Support For Different Transports
        • Configure State Persistence
        • Configure Cluster Coordination
        • Add Third Party Non OSGi Libraries
        • Configure Default Ports
        • Change the Host Name and Context Path of Web UI Applications
        • Enable Logs for Received Event Count
      • Deployment Patterns Overview
          • All-in-One Deployment Overview
          • Configure a Single API-M Node
          • Configure an Active-Active API-M Deployment
          • Distributed Deployment Overview
          • Configure a Distributed API-M Deployment
          • Configure a Distributed API-M Deployment with Traffic Manager Separation
          • Run the API-M Profiles
        • Configure a Micro Integrator Cluster
        • Deployment Synchronization
        • Streaming Integrator Deployment Overview
        • Single Node Deployment
        • Minimum HA Cluster
        • Active-Active Cluster
        • Scalable Cluster
        • Minimum Ha Cluster in AWS ECS
          • Deploy API-M on K8s Using Helm Resources
          • Micro Integrator Deployment Patterns on K8s
          • Deploy the Micro Integrator on K8s
          • Install the API K8s Operator
          • Deploy APIs Using the Operator
          • Deploy Integrations Using the Operator
          • Deploy Integrations Using Helm Resources
            • Sample 1 - Target Endpoint
            • Sample 2 - Deployment Params and Certs
            • Sample 1 - Hello World
            • Sample 2 - Message Routing
            • Sample 3 - JMS Sender/Receiver
        • Deployment Checklist
        • Security Guidelines for a Production Deployment
        • Basic Health Checks
        • Change the Hostname
        • Change the Default Ports
        • Monitor Integration Transaction Counts
        • Backup and Recovery
          • API-M Performance Tuning
            • Tuning JVM Performance
            • Tuning Network and OS Performance
            • Tuning JDBC Configurations
            • Tuning the HTTP Transport
            • Tuning the JMS Transport
            • Tuning the VFS Transport
            • Tuning the RabbitMQ Transport
            • Tuning the Inbound Endpoints
        • CI/CD for Integrations - Overview
        • Build a CI/CD Pipeline for Integrations (VM deployment)
        • Build a CI/CD Pipeline for Integrations (K8s deployment)
        • Building a CI/CD Pipeline for Streaming Integrations (K8s deployment)
        • CI/CD for APIs - Overview
        • Build a CI/CD Pipeline for APIs Using the CLI
        • Build a CI/CD Pipeline for APIs using Jenkins
        • Getting Started with WSO2 API Controller (apictl)
          • Manage APIs and API Products
          • Import APIs Via Dev First Approach
          • Migrate APIs to Different Environments
          • Migrate API Products (with or without Dependent APIs) to Different Environments
          • Manage Applications
          • Migrate Apps to Different Environments
          • Manage Rate Limiting Policies
          • Migrate Rate Limiting Policies to Different Environments
          • Manage Common API Policies
          • Migrate Common API Policies to Different Environments
        • Manage APIs in Kubernetes
        • Manage Choreo Connect
        • Manage Integrations
        • Encrypt Secrets with apictl
        • Enable Correlation Logs with apictl
          • Create Custom Users to Perform apictl Operations
          • Configure Environment Specific Parameters
          • Use Dynamic Data in apictl Projects
          • Configure Different Endpoint Types
          • Configuring Different Endpoint Security Types
          • Format the Outputs of Get Commands
          • Configure Git Integration
    • Upgrade
      • Common Runtime and Configuration Artifacts
      • Default Product Ports
      • Product Compatibility
        • API Manager
        • API Manager (Streaming APIs)
        • API Manager (GraphQL APIs)
        • Micro Integrator
      • Supported Cipher Suites
    • Tutorials Overview
    • Expose an Integration Service as a Managed API
    • Develop an Integration From a Managed API
    • Expose an Integration SOAP Service as a Managed API
      • Scenario Overview
      • Scenario 1 - Create a REST API from an OpenAPI Definition
      • Scenario 2 - Engage Access Control to the API
      • Scenario 3 - Implement an API
      • Scenario 4 - Sign Up a New User
      • Scenario 5 - Get the Developer Community Involved
      • Scenario 6 - Integrate with Data Sources
      • Scenario 7 - Analytics
      • Scenario 8 - Rate Limiting
      • Scenario 9 - Realtime Data with WebSocket API
      • Scenario 10 - Notifications Using WebHooks
      • Scenario 11 - GraphQL Support
      • Scenario 12 - Guaranteed Message Delivery
      • Scenario 13 - Integrate with Services via Connectors
      • Scenario 14 - External Key Manager Support
      • Create and Publish a GraphQL API
        • Create and Publish a WebSocket API
        • Create and Publish a WebSub/WebHook API
        • Create and Publish a SSE API
      • Create and Publish an AWS Lambda API
      • Expose a SOAP Service as a REST API
      • Edit an API by Modifying the API Definition
      • Integrating API Manager with an External Broker and Gateway
      • Send a Simple Message to a Service
        • Routing Requests based on Message Content
      • Expose Serveral Services as a Single Service
        • Translate Message Formats
        • Store and Forward Messages for Guaranteed Delivery
        • Send Emails from an Integration Service
        • Expose Datasources as a Service
      • File Processing
      • Execute Integration Processes Periodically
      • Use Inbound Endpoints
      • Reuse Mediation Sequences
      • Integrate with SAP
      • Tutorials Overview
      • Expose a Kafka Topic as a Managed WebSocket API
      • Perform Real-time ETL with MySQL
      • Perform Real-time ETL with Files
      • Create an ETL Application via Wizard
      • Kafka
      • Integrate Stores
      • Business Rules
      • Expose Processed Data as API
      • Manage Streaming Data with Errors
      • Trigger Integrations via MI
      • Run SI with Docker and Kubernetes

Previous Admin API v4
Next Service Catalog API v1
WSO2 API Manager - Documentation
Copyright © WSO2 LLC 2015-2023
Content licensed under CC By 4.0. | Sample code licensed under Apache 2.0.