logo
API Manager Documentation 4.2.0
Gateway API v2
4.2.0
  • Show all
Initializing search
    wso2/docs-apim
    • 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
          • Multiple Active Access Tokens
          • 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
        • API Governance CLI Tool
        • 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
            • 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
          • Modify Workflow Approval Task Limit
        • 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
        • Configure the Global 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 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
                • Intergrate with HashiCorp Vault
              • 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
            • Configure the Crypto Provider
          • 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
            • Multi-DC Deployment Patterns Overview
            • Configure Multi-DC Deployment - Pattern 1
            • Configure Multi-DC Deployment - Pattern 2
          • 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

    Back to top
    Previous Admin API v4
    Next Service Catalog API v1
    WSO2 API Manager - Documentation
    Made with Material for MkDocs
    Copyright © WSO2 LLC 2015-2024
    Content licensed under CC By 4.0. | Sample code licensed under Apache 2.0.