• webMethods API Gateway Documentation
•  About this Documentation
  • Document Conventions
  • Online Information and Support
  • Data Protection
•  Getting Started with API Gateway
  • What is API Gateway?
  •  Deployment
    • Install Stand-alone API Gateway using Docker
    • Install API Gateway using Software AG Installer
  •  Create your first REST API
    • Creating a REST API by importing an API from a file
    • Creating a REST API by importing an API from a URL
    • Testing a REST API
  •  Create your first SOAP API
    • Creating a SOAP API by importing an API from a file
    • Creating a SOAP API by importing an API from a URL
    • Testing a SOAP API using SOAPUI
    • Testing a SOAP API using curl
  •  Create your first GraphQL API
    • Creating a GraphQL API by Importing an API from URL
    • Creating a GraphQL API by Importing an API from a File
    • Testing a GraphQL API using Postman
  • Publish an API to Developer Portal
  • Monitor your API
  • Debug an API
  • API Mocking
  • Authenticate an API
  •  Rate limit your APIs
    • Configuring Rate Limit for an API
    • Testing the API Rate Limit
  • API Transaction Logging
  •  Request and Response Transformation
    • Use case 1: E-Commerce API Request Header Transformation
    • Use case 2: Response Message Transformation
    • Testing Request and Response Transformation Policies
  • Global Policies
  • Routing Policies
•  Administering API Gateway
  •  Deployment
    •  Concepts
      • Security Considerations
      • API Gateway Editions
      • Reverse Invoke in API Gateway
      • API Gateway Components
      •  Deployment Models
        • Single-node Deployment
        •  Multi-node Cluster Deployment
          • High Availability, Disaster Recovery, and Fault Tolerance
          • Disaster Recovery vs Fault Tolerance
          • Cluster Deployment Options
      • External Elasticsearch and Kibana
      •  Reference Architectures
        • Recommended High Availability Architecture
        • High Availability and Disaster Recovery (HADR) solution
        • High Availability and Fault Tolerance (HAFT) solution
      • API Analytics
      • Containerization
      • Product Configurations
    •  Deployment Configurations
      •  Cluster Deployment
        • API Gateway Cluster Configuration
        • Enabling Clustering for API Gateway through the User Interface
        • Terracotta Server Array Configuration
        •  API Data Store Cluster Configuration
          • Configuring Elasticsearch Cluster
          • Adding New Nodes to an Elasticsearch Cluster
        • Load Balancer Configuration
        • Ports Configuration
        • Configuring Multiple Instances of API Gateway in a Single Installation
      •  Paired Deployment
        • Configuring Reverse Invoke Setup
        • Paired Deployment with Integration Server in Green Zone
        • Importing a Certificate and Mapping to User
        • Troubleshooting Tips: API Gateway and DMZ Connectivity
      •  Connecting to an External Elasticsearch
        • Troubleshooting Tips: External Elasticsearch
      • Connecting to an External Kibana
      •  Externalizing Configurations
        • Using the Externalized Configuration Files
        • Default Scenario
        • Troubleshooting tips: Externalized Configuration
        •  Connecting webMethods API Gateway to API Control Plane
          • API Control Plane Agent Configuration
          • API Control Plane Agent Properties
          • API Control Plane Agent Configuration using Properties
          • API Control Plane Agent Configuration using YAML file
          • Connecting API Gateway to API Control Plane using API Gateway UI
          • Logger Configuration
      • API Gateway Standard and Advanced Editions Capability Matrix
      • API Gateway, Elasticsearch, Kibana, and TSA Compatibility Matrix
  •  Operating API Gateway
    • Administering API Gateway through API Gateway User Interface
    •  Starting and Stopping API Gateway
      • Starting and Stopping API Gateway Using Scripts
      • Shut down or Restart API Gateway Using User Interface
    •  Data Management
      • Types of Data and their Storage
      • Difference between Archive and Backup
      •  Data Housekeeping
        • Archive and Purge using API
        • Creating Rollover of indexes that exceed the maximum size
        • Restoring Archived Data using API
        •  Archive and Purge using UI
          • Archiving Data
          • Purging Data
        • Restoring Archived Data using UI
        • List of events that can be archived or purged
        • Job Listing
        • Archive and Purge Configuration
      •  Data Backup
        • Backup Requirements Analysis
        • Backup Repository Capacity Sizing
        • Backup Considerations
        • Backup Operation
        •  Data Store Backup
          •  Backup Repository
            • Configuring a Local File System Repository
            • Configuring a Network File System Repository
            • Configuring a Cloud Repository in Amazon S3
          • Creating API Data Store Backup
        •  Advanced Backup Options
          • Creating Backup of specific Indexes
          • Creating Rollover of an Index
          • Conditions that can be given with rollover command
          • Viewing Backup Files List
          • Verifying Backup Status
          • Deleting a Backup File
          • Specifying Log File Details
          • Viewing Exit Codes for Backup Script Operations
          • List of Indexes that can be included in backup
          • List of Indexes that can be backed up individually
        •  Platform Data Backup
          • Creating Platform Data Backup using Script
          • Creating Platform Data Backup Manually
        • Backup folders monitoring
        • Troubleshooting a Failed Backup
        • Troubleshooting Tips: API Data Store Backup
        •  Restore Operation
          • Restoring Data Store Backup
          • Verifying Restore Status
          • Restoring Platform Data backed up using the Script
          • Restoring the manually backed up Platform data
          • Troubleshooting a Failed Restore
        • Adding New Nodes to an Elasticsearch Cluster
      • Troubleshooting Tips: API Data Store
    •  Monitoring API Gateway
      • Cluster-level Monitoring
      • Troubleshooting: Cluster-level Monitoring
      •  Node-level Monitoring
        •  Monitoring API Gateway
          • Monitoring API Gateway through Prometheus Metrics
          • Application Metrics
          • API Operational Metrics
          • Monitoring API Gateway Health
          • System Metrics
          •  Monitoring API Gateway through Dashboards
            • API Gateway Dashboard
            • Creating custom dashboards
            • Kibana Limitations
          •  Runtime Events and Metrics Data Model
            • API Gateway
            • API Portal
            • Audit Log
            • CentraSite
            • Elasticsearch
            • Email
            • JDBC
            • Local Log
          • Troubleshooting: Monitoring API Gateway
          • How Do I Generate Thread Dump?
          • How Do I Generate Heap Dump?
          • Causes for timeout errors
        •  Monitoring API Data Store
          • Application Metrics
          •  Infrastructure Metrics
            • Container Metrics
          • Troubleshooting: Monitoring API Data Store
        •  Monitoring Terracotta
          •  Infrastructure Metrics
            • Container Metrics
          • Troubleshooting: Monitoring Terracotta Server Array
        • Monitoring Kibana
        • Troubleshooting Tips: Monitoring Performance
    •  General Administration Configuration
      •  Clusters and Load Balancers
        • Configuring Load Balancer URLs
      • Configuring Extended Settings
      • Configuring API Fault Settings
      •  Approval Configuration
        • Configuring Approvals for Creating an Application
        • Configuring Approvals for Registering Application
        • Configuring Approvals for Updating Application
        • Configuring Approvals for Subscribing Package
        • Configuring Approvals for Updating Subscription
        • Configuring Approvals for Deleting Subscription
        • How Do I Configure the Approval Process for Ownership Change of Assets?
        • Email templates variable
        •  Approval Requests
          • Deleting Requests
      •  Outbound Proxy
        • Configuring Proxy Server Alias
        • Modifying a Proxy Server Alias
        • Deleting a Proxy Server Alias
      •  Proxy Bypass
        • Adding a Proxy Bypass
        • Modifying a Proxy Bypass
        • Deleting a Proxy Bypass
      •  URL Aliases
        •  Creating URL Alias
          • Using Port Mappings with URL Alias
          • Adding Port Mapping to URL Alias
          • Deleting Port Mapping for URL Alias
        • Enabling Partial Matching of URL Aliases
        • Modifying a URL Alias
        • Deleting a URL Alias
        • Example: Usage Scenarios of URL Aliases
      •  Custom Content-types
        • Configure Custom Content-types
      •  Cache Configuration
        • Configuring Cache to Improve Performance
      •  Application Log Configurations
        • Configuring Log Levels
        • Downloading the Log Files
        •  Configuring Log Aggregation
          • Filebeat
        • Logs Housekeeping
      •  License Configuration
        • Viewing Licensing Information
        • Configuring Licenses
      • Configuring API Callback Processor Settings
      •  Messaging
        • Creating a JNDI Provider Alias
        • Creating a JMS Connection Alias
      •  Web Services Endpoint Alias
        • Creating an Endpoint Alias for a Provider Web Service Descriptor
        • Creating an Endpoint Alias for a Consumer Web Service Descriptor
      •  JMS Triggers
        • Updating JMS triggers
    •  Users, Groups, and Teams
      • Adding a User
      • Modifying User Details
      • Deleting a User
      •  User Groups
        • Adding a Group
        • Modifying a Group
        • Deleting a Group
        • API Gateway Functional Privileges
      •  Team Support
        • When to use Team support?
        • What is a Team in API Gateway?
        • When not to use Team support?
        • Teams management using API Gateway
        • Enabling Team Support
        • Creating Teams
        • How do I Assign Teams during Asset Creation?
        • How do I Assign Teams Using Team Assignment Rule?
        • How do I Modify Teams Assigned to an API?
        • How do I Change the Ownership of Multiple Teams?
        • Team Support Considerations
        • Scenarios where you cannot use Teams support
      • Setting Password Restrictions
      • Setting Password Expiry Restrictions
      • Configuring Account Locking Settings
      • Unlocking User Accounts
      • Restricting User Accounts
      • Configuring API Gateway to Use LDAP
      • Managing LDAP Directories
      •  User Settings and Preferences
        • Changing Your Account Settings
        • Changing Your Password
        • Changing Your Display Language
        • Viewing Your Roles and Permissions
    •  Destination Configuration
      •  Configuring Events for API Gateway Destination
        • Troubleshooting Tips: API Gateway Destination
      •  Configuring Developer Portal Destination
        • Troubleshooting Tips: Developer Portal Destination
      • Configuring Events for API Portal Destination
      • Configuring API Control Plane
      • Configuring Transaction Logger Destination
      • Configuring CentraSite Destination
      • Configuring Events for CentraSite Destination
      • Configuring Events for Database Destination
      • Configuring Events for Digital Events Destination
      •  Configuring Elasticsearch Destination
        • Troubleshooting Tips: Elasticsearch Destination
      • Configuring Events for Elasticsearch Destination
      •  Configuring Email Destination
        • Configuring Email Templates
      • Configuring SNMP Destination
      • Configuring Events for SNMP Destination
      •  Custom Destination
        •  How Do I Publish Data to an External Endpoint using Custom Destination?
          • How Do I Publish API-specific Traffic Monitoring Data to a Custom Destination?
        • How Do I Publish Data to an Integration Server Service using Custom Destination?
        • How Do I Publish Data to an AWS Lambda Function using Custom Destination?
        • How Do I Publish Data to a Message Queue using Custom Destination?
      • Troubleshooting Tips: API Gateway - API Portal Integration
    •  Audit Logging
      • Configuring Audit Logs
      • Viewing Audit Logs
      • Downloading Audit Logs
    •  System Settings
      • Modifying API Gateway Configuration Parameters
      •  SAML SSO
        • SAML Assertion
        • How to enable SAML SSO in API Gateway?
        • Precedence in Group Mapping
        • Troubleshooting Tips: SSO configuration
    •  Configuring External Accounts
      • Adding a Service Registry
      • Removing a Service Registry
      • Configuring an AWS Alias
      • Configuring Integration Server Instance for API Implementation
    •  Configuration Types and Properties
      • webApp Configuration Properties
      • API Gateway Package Configuration Properties
      • Troubleshooting Tips: wmAPIGateway Package
  •  Security Configuration
    • Overview of Security Configuration in API Gateway
    •  Keystore and Truststore
      • Configuring Keystore Information
      • Modifying Keystore Information
      • Deleting Keystore Information
      • Configuring Truststore Information
      • Modifying Truststore Information
      • Deleting Truststore Information
      • Configuring Keystore and Truststore Information for Inbound Messages
      • Configuring Keystore and Truststore Information for Outbound Connections
    •  Ports
      • Adding an HTTP Port
      • Adding an HTTPS Port
      • Adding an API Gateway External Port
      • Configuring the API Gateway Internal listener
      • Configuring the WebSocket Listener
      •  Configuring IP Access Mode for a Port
        • Allowing Access to All IP Hosts
        • Denying Access to All IP Hosts
      • Configuring Access Mode for a Port
      • Deactivating Default Primary Port
    •  Global IP Access Settings For Ports
      • Allowing Connections from Specified Hosts
      • Denying Connections from Specified Hosts
      • If You Inadvertently Deny IP Access to All Hosts
      • Configuring Restriction to IP Address based on Authentication
    • SAML Issuer
    •  Custom Assertions
      • Creating a Custom Assertion
      • Viewing Custom Assertion List and Assertion Configuration
      • Modifying Custom Assertion
      • Deleting Custom Assertion
      • Example: Custom Assertions
    •  Kerberos Settings
      • Configuring API Gateway to Use Kerberos
    •  Master Password Management
      • Backing up the Password and Master Password Files
      • Updating the Master Password
      • Managing Master Password Expiry Interval
      • Advanced Configuration to Manage Master Password
      • Restoring the Password and Master Password Files
      • Resetting the Master Password
    •  OAuth, JWT, and OpenID Configuration
      • Configuring the Internal Authorization Server
      • Adding a Provider
      • Adding an External Authorization Server
      • OAuth or OpenID Scopes
      • Viewing Scope Mapping Details
      • Viewing Provider List and Provider Configuration
      • Modifying the Provider Configuration
      • Viewing Authorization Server List and Server Configuration
      • Modifying Authorization Server Configuration
      • Deleting an Authorization Server
      • Deleting a Provider
      • Configuring Communication Details for Microgateway
      • Removing Expired OAuth Tokens
      • Revoking OAuth Tokens
    •  Threat Protection Policies
      • Configuring Global Denial of Service Policy
      • Configuring Denial of Service by IP Policy
      • Managing Denied IP List
      • Configuring Rules
      • Registering a Mobile Device or Application
      • Configuring Alert Settings
    •  Securing API Gateway Communication using TLS
      • How Do I Secure API Gateway Server Communication with API Clients?
      • How Do I Secure API Gateway Server Communication with Backend Services?
      • How do I Secure API Gateway User Interface Communication?
      • How do I Configure a Secure Communication Channel between API Gateway and API Portal?
      •  How do I Secure API Data Store Communication using HTTPS?
        • How do I Secure API Data Store Communication using HTTPS with ReadonlyREST Plugin?
        • Creating a Custom Keystore with Self-Signed Certificates
    • Troubleshooting Tips: Securing API Data Store (Elasticsearch)
  •  Container-based Provisioning
    •  Docker Configuration
      • Building the Docker Image for an API Gateway Instance
      • Retrieving Port Information of the API Gateway Image
      • Running the API Gateway Container
      • Load Balancer Configuration with the Docker Host
      • Stopping the API Gateway Container
      • Managing API Gateway Images
      • API Gateway Docker Container with Externalized Elasticsearch and Kibana
      • API Gateway Container Cluster Configuration
      •  Running API Gateway Docker Containers with Docker Compose
        • Running a Single API Gateway and an Elasticsearch Container
        • Running Clustered API Gateway Containers and Elasticsearch Containers
        • Running Clustered API Gateway and Elasticsearch Containers and a Kibana Container
      •  Data Backup using Docker Container
        • Building Docker Image on top of the public API Gateway Image
        • Building Docker Image on top of the local API Gateway installation
        •  Running the API Gateway Utility Container
          • Exiting the container after performing an operation
          •  Running the API Gateway Utility Container
            •  Exiting the container after performing an operation
              • Keeping the container alive to perform multiple backup operations
          • Entering into a container to perform a backup operation
          •  Checking the API Gateway Utility logs
            • Viewing Console Logs
            • Viewing the help text or the list of existing commands
          • Checking the exit code of the command
      • Troubleshooting Tips: Docker Configuration
    •  Kubernetes Support
      • Deploying API Gateway Pod with API Gateway and Elasticsearch Containers
      • Deploying API Gateway Pod with API Gateway Container connected to an Elasticsearch Kubernetes Service
      • API Gateway Clustering on Kubernetes
      • Kubernetes Sample Files
      • Helm Chart
      • Using Helm to Start the API Gateway Service
      •  OpenShift Support
        • Building a Docker Image for an API Gateway Instance in OpenShift Environment
        • Running the API Gateway Docker Image with the sagadmin User
        • OpenShift Sample Files
  •  High Availability, Disaster Recovery, and Fault Tolerance
    •  High Availability
      • Disaster Recovery vs Fault Tolerance
      • Keypoints about High Availability and Disaster Recovery (HADR) solution
      • Keypoints about High Availability and Fault Tolerance (HAFT) solution
    •  High Availability and Disaster Recovery
      •  What is Cold Standby Mode?
        • How Do I Set Up Data Center in Cold Standby Mode?
        • How Do I Set Up Data Center in Cold Stand By Mode With Backup of Assets Data Only?
      •  What is Warm Standby Mode?
        • How Do I Set Up Data Center in Warm Standby Mode?
    •  High Availability and Fault Tolerance
      • What is Hot Standby Mode?
      • What is Active-Active Mode?
      • Data Synchronization in Hot Standby and Active-Active Modes
      • How Do I Set Up the Data Centers in Hot Standby Mode Using Basic Operation?
      • How Do I Set Up the Data Centers in Hot Standby Mode Using Composite Operation?
      • How Do I Set Up the Data Centers in Active-Active Mode Using Basic Operation?
      • How Do I Set Up the Data Centers in Active-Active Mode Using Composite Operation?
      •  How does Cross-DC Support Detect Data Center Failures?
        • How Do I Monitor the Health Status of the Data Center?
      • How Do I Bring Down a Single Data Center from Active-Active or Hot Standby Mode to Standalone Mode?
      • How Do I Bring Down Multiple Data Centers from Active-Active or Hot Standby Mode to Standalone Mode?
      • How Do I Read the Current Configuration of the Data Center?
      • Cross-DC Extended Settings
  •  Performance Tuning and Scaling
    •  Hardware and Product Configurations
      • Resource Sizing Guidelines
      • Logging Configurations
      • Product Configurations Guidelines
    • Changing the JVM Heap Size to Tune API Gateway Performance
    •  Data Separation
      • Storing Analytics Data in external Elasticsearch
      • Configuring Analytics Data Store using UI
      • Configuring Analytics Data Store manually
      • Connecting to Analytics Data Store
    •  Scaling
      • Scaling up API Gateway
      • Scaling up API Gateway in a Reverse Invoke setup
      • Scaling up API Data Store
      • Scaling down API Gateway
      • Scaling down API Gateway in a Reverse Invoke setup - DMZ Zone
      • Scaling down API Gateway in a Reverse Invoke setup - Green Zone
      • Scaling down API Data Store
  •  Remove User Data from API Gateway
    • Removing User Data
  •  API Gateway Configuration with Command Central
    • Overview
    •  Install API Gateway using Command Central
      • Installing API Gateway using Command Central Commands
    •  Manage API Data Store Configurations in Command Central
      •  Administering API Data Store
        •  Starting, Stopping, and Restarting API Data Store
          • Starting and Stopping API Data Store in Command Central
          • Starting, Stopping, and Restarting API Data Store on Windows
          • Starting, Stopping, and Restarting API Data Store on LINUX
        • Changing the API Data Store HTTP Port
        • Changing the API Data Store HTTP Port using Template
        • Changing the API Data Store TCP Port
        • Configuring an API Data Store Cluster
        • Configuring Data Store Cluster using Template
        • Configuring Custom API Data Store Properties
        • Configuring Elasticsearch Properties
        • Configuring Elasticsearch Properties using Template
    •  Manage API Gateway Product Configurations in Command Central
      • Configuring Properties
      • Configuring Keystores
      • Configuring Keystores using Template
      • Configuring Licenses
      • Configuring Loggers
      • Configuring HTTP Port
      • Configuring HTTPS Port
      • Configuring HTTPS Port using Template
      • Configuring Truststores
      • Configuring Truststores using Template
    •  Manage Inter-component and Cluster configurations
      •  Configuring Elasticsearch Connection Settings
        • Configuring External Elasticsearch using Template
      •  Configuring Kibana Connection Settings
        • Configuring Kibana using Template
      •  Configuring API Gateway Cluster
        • Configuring Cluster using Template
    •  Command Line to Manage API Data Store
      • Commands that API Data Store Supports
      • Configuration Types that API Data Store Supports
      • Run-Time Monitoring Statuses for API Data Store
      • Lifecycle Actions for API Data Store
    • Troubleshooting Tips: API Gateway Configuration with Command Central
•  Using API Gateway
  •  Define and Manage APIs
    • Defining and Managing APIs
    • Creating an API by Importing an API from a File
    • Creating an API by Importing an API from a URL
    •  Creating an API from Scratch
      • Creating a REST API from Scratch
      • Creating a WebSocket API from Scratch
    •  Viewing API List and API Details
      • REST API Details
      • SOAP API Details
      • OData API Details
      • GraphQL API Details
    • Searching Data in API Gateway
    • Filtering APIs
    • Configuring the Number of APIs listed on a Page
    • Modifying API Details
    •  Updating APIs
      • Updating an API by Importing an API from a File
      • Updating an API by Importing an API from a URL
    • Exporting Specifications
    • Attaching Documents to an API
    • API Grouping
    •  API Tagging
      • Adding Tags to an API
    •  Versioning APIs
      • Creating New API Version
    •  Deleting APIs
      • Deleting a Single API
      • Deleting Multiple APIs in a Single Operation
    • Example: Managing an API
    • CentraSite Provided APIs
  •  Implement APIs
    • API Implementation
    •  API Mocking
      • Enabling API Mocking
      • Modifying API Mocking Details
      • Custom Replacer
    •  Consumer Applications
      • Creating an Application
      • Viewing List of Applications and Subscriptions
      • Regenerating API Access Key
      • Modifying Application Details
      • Registering an API with Consumer Applications from API Details Page
      • Suspending an Application
      • Activating a Suspended Application
    •  Policies
      •  Transport
        •  Enable Bulkhead
          • Enabling bulkhead for APIs at the API level
          • Bulkhead feature considerations
        • Enable HTTP/HTTPS
        • Set Media Type
        •  Enable JMS/AMQP
          • Configuring API Gateway for JMS with AMQP Protocol
          • Using Enable JMS/AMQP for a SOAP API
          • Using Enable JMS/AMQP for a REST API
      •  Identify and Access
        •  Identify & Authorize
          • OAuth Authentication in API Gateway
          • Securing APIs using OAuth 2.0 in API Gateway with Local Authorization Server
          • Securing APIs using OAuth 2.0 with API Gateway as Resource Server and Remote Integration Server as Authorization Server
          • Securing APIs using OAuth 2.0 in API Gateway using Third Party Authorization Server
          • Securing APIs Using OAUTH 2.0 In API Gateway Using External Ports
          • Defining Multpile OAuth 2.0 Scopes in API Gateway
          • Retrieving OAuth Token
          •  Secure API using OAuth2 with refresh token workflow
            • Configuring OAuth2 Authentication with Refresh Token
            • Refresh Token Process Flow
            • How to get the access token with resource owner permission?
            • How to get the access token without resource owner permission using refresh token in the subsequent attempts?
          •  JWT Authentication Use case and Workflow
            • Retrieving JWT Token
            • Retrieving JWT Token with Claim
          • OpenID Authentication Use case and Workflow
          •  Securing Access Token Calls with PKCE
            • How do I enforce PKCE globally?
            • How do I secure the access token with Authorization Code (With PKCE) grant type using postman?
            • How do I secure the access token by directly calling API Gateway's REST APIs?
            • How do I enforce PKCE selectively for each access token call?
            • How do I generate code verifier and code challenge using JAR files?
        • Inbound Auth - Message
        • Authorize User
      •  Request Processing
        • Validate API Specification
        • Request Transformation
        • Invoke webMethods IS
        • Data Masking
      •  Routing
        • Straight Through Routing
        • Custom HTTP Header
        • Outbound Auth - Transport
        • Content-based Routing
        • Conditional Routing
        • Dynamic Routing
        • Load Balancer Routing
        • Outbound Auth - Message
        •  JMS/AMQP Policies
          • JMS/AMQP SOAP Routing
          • JMS/AMQP REST Routing
        • JMS/AMQP Properties
      •  Traffic Monitoring
        •  Log Invocation
          • Uncompressing a payload
        • Traffic Optimization
        • Service Result Cache
        • Monitor Performance
        • Monitor SLA
      •  Response Processing
        • Validate API Specification
        • Response Transformation
        • Invoke webMethods IS
        • Data Masking
        • CORS
      •  Error Handling
        • Conditional Error Processing
        • Data Masking
      • Policy Validation and Dependencies
      • Variable Framework
      •  Custom Policy Extension
        • How Do I Invoke an API through HTTP or HTTPS using Custom Extension?
        • How Do I Invoke an IS Service using a Custom Extension?
        • How Do I Invoke an AWS Lambda Function using Custom Extension?
        • How Do I Invoke an API Asynchronously through JMS/AMQP using a Custom Extension?
        • How Do I Define a Custom Variable?
        • Custom Extension Properties
        • Data Objects and Variables Available in API Gateway
      •  Request and Response Transformation Policies
        • How do I transform a request using Request Transformation Policy?
        • Request Transformation Policy Properties
        • How do I transform a request and its response using Transformation Policy?
        • Response Transformation Policy Properties
      •  Invoke webMethods IS Policy
        • How do I transform a request using Invoke webMethods IS policy?
        • Invoke webMethods IS Policy Properties for Request Processing
        • How do I transform a response using Invoke webMethods IS policy?
        • Invoke webMethods IS Policy Properties for Response Processing
      • System Context Variables
      • The API for Context Variables
      • Assigning a Policy to an API
      • Viewing API Policy Details
      • Modifying API Policy Details
    •  Aliases
      • Creating a Simple Alias
      • Creating an Endpoint Alias
      • Creating an HTTP Transport Security Alias
      • Creating a SOAP Message Security Alias
      • Creating a webMethods Integration Server Service Alias
      • Creating an XSLT Transformation Alias
      • Supported Alias and Policy Combinations
    •  Global Policies
      • Creating a Global Policy
      • Modifying the Scope of a Global Policy
      • Refining the Scope of a Global Policy
      • Associating Policies to a Global Policy
      • Configuring Properties for a Global Policy
      • Viewing List of Global Policies and Policy Details
      • Modifying Global Policy Details
      • Activating a Global Policy
      • Deactivating a Global Policy
      • Deleting a Global Policy
      • Copying a Global Policy
      • Exporting Global Policies
    •  Scope-level Policies
      •  API Scopes
        • Creating an API Scope
        • Viewing List of API Scopes and Scope Details
        • Modifying API Scope Details
        • Deleting an API Scope
      • Creating a Scope-level Policy
      • Viewing List of Scope-level Policies and Policy Details
      • Modifying Scope-level Policy Details
      • Deleting a Scope-level Policy
    • Example: Usage Scenarios of API Scopes
    •  Policy Templates
      • Creating a Policy Template
      • Associating Policies with a Policy Template
      • Configuring Properties for a Policy Template
      • Viewing List of Policy Templates and Template Details
      • Modifying Policy Template Details
      • Deleting a Policy Template
      • Copying a Policy Template
      • Applying a Policy Template on the API Details Page
      • Modifying a Policy Template on the API Details Page
      • Saving Policy Definition of an API as Policy Template
    •  Change Ownership of Assets
      • How Do I Change the Ownership of an API?
      • How Do I Change the Ownership of an Application?
      • How Do I Change the Ownership of Multiple Assets?
    •  Debugging API
      • How do I enable tracing?
      • How do I filter the runtime request?
      • How do I view the trace details?
      • How do I inspect failed runtime requests using tracer?
      • How do I import runtime requests?
      • How do I export or download runtime requests?
      • How do I archive or purge the tracer details?
      • How do I archive and purge the tracer details using REST API Calls?
    •  API Mashups
      • Creating an API Mashup
    •  SOAP to REST Transformation
      • Activating SOAP to Rest Transformation
      • Modifying the REST Definitions for SOAP Operations
      • Supported Content-types and Accept Headers
      • REST API Endpoints
      • Samples for REST Request
      • Limitations
    •  API First Implementation
      • API First Implementation using Integration Server
      • API First Implementation using a Third-party Server
      • List of Parameters used in API Implementation
    • Troubleshooting Tips: Implement APIs
  •  Publish APIs
    • Why Publish APIs?
    •  Activating an API
      • WSDLs in API Gateway
    • Deactivating an API
    • Exposing a REST API to Applications
    • Exposing a SOAP API and GraphQL API to Applications
    •  Gateway Endpoints
      • How do I Define API-specific Gateway Endpoints?
      •  How do I Define Global Gateway Endpoint?
        • How do I Edit Global Gateway Endpoint?
        • How do I Delete Global Gateway Endpoint?
      • Other Gateway Endpoint Usecases
    •  Publishing APIs to API Portal
      • Publishing a Single API to API Portal
      • Publishing Multiple APIs to API Portal in a Single Operation
      •  Unpublishing APIs from API Portal
        • Unpublishing a Single API from API Portal
        • Unpublishing Multiple APIs from API Portal in a Single Operation
    •  Publishing APIs to Service Registries
      • Publishing a Single API to Service Registries
      • Publishing Multiple APIs to Service Registries in a Single Operation
      •  Unpublishing APIs from a Service Registry
        • Unpublishing a Single API from Service Registries
        • Unpublishing Multiple APIs from Service Registries in a Single Operation
    •  Publishing APIs to Integration Server
      • Publishing a Single API to Integration Server
      • Publishing Multiple APIs to Integration Server in a Single Operation
      •  Unpublishing APIs from Integration Server
        • Unpublishing a Single API from Integration Server
        • Unpublishing Multiple APIs from Integration Server in a Single Operation
  •  Monetize APIs
    • API Monetization
    • Packages and Plans
    • Creating a Package
    • Creating a Plan
    • Activating a Package
    • Publishing a Package
    • Viewing List of Packages and Package Details
    • Viewing List of Plans and Plan Details
    • Viewing a List of Subscriptions
    • Modifying a Package
    • Modifying a Plan
    • Deleting a Package
    • Deleting a Plan
  •  Monitor APIs
    • Analytics
    • API-specific Dashboard
  •  Microservices
    • Manage Microservices
    •  Microgateways
      • Microgateway Groups
      • Microgateway Group Analytics
      • Microgateway Details
      •  Deleting Microgateway Instances
        • Deleting a Microgateway
        • Deleting Multiple Microgateways
    •  AppMesh Support
      •  Configure API Gateway to Connect to a Service Mesh Environment
        • Creating a Microgateway Image
      •  AppMesh Deployment
        • Service Discovery
        • APIfy
        • Update API Definition and Policies
        • Deploy AppMesh
      • Undeploy AppMesh
      • Provisioning of API and Policy Updates
  •  Accessibility Profile
    • Web Content Accessibility Guidelines
•  Staging and Promotion
  • Introduction
  •  Asset Promotion
    • Asset Promotion
    • Promoting Assets Using Promotion Management API
    •  Promoting Assets from API Gateway User Interface
      • Viewing Promotion List and Promotion Details
      • Adding a Stage
      • Repromoting Assets
      •  Rollbacks
        • Rollback Asset Promotions
        • Viewing Rollback List and Rollback Details
    • Promoting Assets Using Deployer
  •  Export and Import Assets and Configurations
    • Export and Import Assets and Configurations
    • Exporting APIs
    • Importing Asset and Configuration Archives
    • Troubleshooting Tips: Import and Export Assets
•  Upgrading and Migrating to API Gateway
  •  Upgrading API Gateway
    • Introduction
    • Upgrading standalone API Gateway
    • Upgrading Elasticsearch in API Gateway
    • Upgrading API Gateway cluster
    • Upgrade configurations
    • Upgrade recovery
    • Troubleshooting Tips
  •  Upgrading API Gateway in Zero Downtime
    •  Introduction
      • API Gateway Quiesce Mode
      • Migration REST API
      • Webhook Notifications
      • Shutdown REST API
    •  Upgrading Major Versions in Zero Downtime
      • Start the new API Gateway instance
      • Clean the data in the new API Data Store
      • Put the old API Gateway instances in quiesce mode for design time
      • Migrate the design time data
      • Transform the design time data
      • Restart new API Gateway instances
      • Add traffic to the new API Gateway instance
      • Put the old API Gateway instances into quiesce mode for all
      • Migrate the analytics data
      • Shutdown the old API Gateway instance
    •  Upgrading Minor Versions in Zero Downtime
      • Upgrade Standalone Deployment
      • Upgrade Cluster Deployment
    • Quiesce Mode
  •  Upgrading API Gateway with external Elasticsearch and Kibana
    • Upgrading API Gateway with external Elasticsearch and Kibana
  •  Migrating from Mediator to API Gateway
    • Migrating from Mediator to API Gateway
•  Developer's Guide
  •  REST APIs in API Gateway
    • API Gateway Administration
    • Alias Management
    • Application Management
    • API Gateway Archive
    • API Gateway Availability
    • Document Management
    • Data Center Management
    • Internal Service
    • Port Configuration
    • Policy Management
    • Promotion Management
    • Public Services
    • API Gateway Search
    • Server Information
    • Service Management
    • Transaction Data
    • User Management
    • Subscription Management
    • Backward compatibility support for REST APIs
    • Troubleshooting Tips: REST APIs
• Copyright

webMethods API Gateway Documentation

Copyright

gtw_configure_cluster

gtw_archive_purge

gtw_restore_data

gtw_archive_purge_config

gtw_gen_config

gtw_configure_load_balancer

gtw_configure_extended_settings

gtw_configure_fault_settings

gtw_configure_approvals

gtw_configure_approvals_create

gtw_configure_approvals_register

gtw_configure_approvals_update

gtw_configure_approvals_subscribe

gtw_update_subscription

gtw_delete_subscription

gtw_configure_approval_change_owner

ta_pending_request

gtw_configure_outbound_proxy

gtw_configure_proxy_bypass

gtw_configure_url_aliases

gtw_custom_content_type

gtw_configure_cache

gtw_configure_loglevels

gtw_download_logfiles

gtw_configure_log_aggregation

gtw_license_info

gtw_configure_license

gtw_configure_callback_settings

gtw_jndi_provider_alias

gtw_jms_connection_alias

gtw_jms_triggers

gtw_manage_users_groups_profiles

gtw_add_user

ta_modify_user

co_user_groups

gtw_add_group

ta_modify_group

gtw_add_profile

gtw_manage_pwd_restrictions

gtw_manage_pwd_expiry_settings

gtw_manage_account_lock_settings

gtw_manage_locked_users

gtw_manage_provider_configuration

gtw_manage_ldap_directories

gtw_manage_user_accounts_settings

gtw_configure_gateway

gtw_configure_portal

gtw_configure_portal_events

gtw_configure_control_plane

gtw_configure_audit_logger

gtw_configure_cs

gtw_configure_cs_events

gtw_configure_database

gtw_configure_des

gtw_configure_es

gtw_configure_es_events

gtw_configure_email

ta_configure_email_template

gtw_configure_snmp

gtw_configure_snmp_events

gtw_configure_custom

gtw_configure_system_settings

gtw_configure_saml_sso

gtw_service_registries

gtw_configure_aws_alias

gtw_configure_is

gtw_sec_config

gtw_configure_keystore

gtw_configure_truststore

gtw_configure_keystore_truststore

gtw_config_key_trust_outbound_connections

gtw_configure_ports

gtw_configure_ipaccessmode

gtw_configure_accessmode

gtw_configure_global_ip

gtw_configure_saml_issuer

gtw_policy_assertions

gtw_configure_policy_assertion

gtw_configure_kerberos

gtw_manage_master_password

gtw_configure_auth_server_int

gtw_configure_provider

gtw_configure_auth_server_ext

gtw_map_oauth_scope

gtw_manage_security_microgateway_communication

gtw_manage_threat_protection_policies

gtw_configure_analytics_ds

gtw_create_api_file

gtw_create_api_url

gtw_create_api_scratch

gtw_create_rest_api_scratch

gtw_create_websockets_api_scratch

gtw_view_api_details

gtw_search

updating_apis

updating_apis_file

updating_apis_url

exporting_specifications

versioning_apis

create_new_versioning_apis

api_mocking

ta_modifying_api_mocking

gtw_manage_applications

gtw_create_application

gtw_view_application_details

ta-modify_appln_ui

gtw_manage_policies

gtw_transport_policies

gtw_iam_policies

gtw_payload_request

gtw_routing_policies

gtw_lmt_policies

gtw_payload_response

gtw_error_handling

gtw_transformation_request

gtw_transformation_response

gtw_manage_aliases

create_is_alias

create_transformation_alias

gtw_manage_global_policies

gtw_create_global_policy

gtw_view_global_policy

gtw_modify_global_policy

exporting_global_policies

gtw_manage_policy_templates

gtw_create_policy_template

gtw_view_policy_template

gtw_modify_policy_template

gtw_apply_policy_template

gtw_add_api_mashup

soap_rest_transformation

modifying_rest_definitions

content_type

endpoint

sample_rest_request

limitations

gtw_manage_apis

gtw_manage_packages

gtw_create_package

gtw_create_plan

ta-modify_package

ta-modify_plan

gtw_analytics

gtw_manage_microgateways

gtw_view_microgateways_group_details

gtw_view_microgateway_details

gtw_appmesh_manage

gtw_configure_service_mesh

gtw_manage_promotions

gtw_add_stage

exporting_apis

exporting_importing_files