SSMNED_12.1.x_cd - Documentation Index

Table of Contents

• Welcome
• API Connect overview
  • What's new in the latest release (version 12.1.1.0)
    • What's new in Version 12.1.0.3
    • What's new in Version 12.1.0.2
    • What's new in Version 12.1.0.1
    • What's new in Version 12.1.0.0
  • Language versions offered by API Connect
  • Known limitations
  • API Connect concepts
    • Who does what in API Connect?
      • API Connect user roles
    • Packaging strategy and terminology in API Connect
      • Understanding rate limits for APIs and Plans
    • API Connect components
      • Gateway types
      • How to choose the right gateway service
    • API Connect support
  • API Connect glossary
  • Accessibility features for IBM API Connect
  • Legal information
    • Tracking API volume for auditing and compliance
    • Notices
    • Terms and conditions for information centers
  • IBM API Connect Considerations for GDPR Readiness
  • Essential reading
• Installing and maintaining IBM API Connect
  • Kubernetes, Cloud Pak for Integration, and OpenShift
    • Planning your deployment
      • Prerequisite skills for administering API Connect
      • Key concepts: Custom Resources, Operators, and Operands
      • Deployment overview for endpoints and certificates
      • Deployment profiles, topologies, and strategies
        • Deployment and component profiles
          • API Connect deployment profiles for OpenShift and Cloud Pak for Integration
          • Component profiles, CPU limits, memory limits, and licensing
            • Management subsystem deployment profile limits
            • CMS Portal component deployment profile limits
            • Developer Portal component deployment profile limits
            • Analytics component deployment profile limits
            • DataPower API Gateway deployment profile limits
            • DataPower Nano Gateway deployment profile limits
            • webMethods API Gateway deployment profile limits
            • Federated API Management component deployment profile limits
        • OpenShift: Deciding to use individual CRs, or a top-level CR, or Cloud Pak for Integration
      • Network requirements for inter-subsystem communication
        • Enable JWT security instead of mTLS
        • In-cluster service communication between subsystems
      • Kubernetes ingress controller and Gateway API prerequisites
        • Installing with Kubernetes Gateway API
      • Persistent Volume (PV) requirements
      • Load balancer configuration
      • Firewall requirements
      • Planning your analytics deployment
      • Key Concepts: Cert-manager, Issuers, and Secrets
      • Webhooks deployed and managed by the API Connect Operator
      • Administering API Connect in your container environment
        • Namespaces in your container environment
        • Custom Resources and Custom Resource Definitions
        • Managing your API Connect CRs
    • Installing API Connect
      • Deployment requirements
        • IBM API Connect Version 12 software product compatibility requirements
        • API Connect licenses
        • Kubernetes: Prerequisites for installing the DataPower Nano Gateway subsystem
          • Installing a gateway API CRD for DataPower Nano Gateway
          • Deploying the DataPower Nano Gateway operator
          • Deploying Valkey Operator and Operand for DataPower Nano Gateway
        • OpenShift: Prerequisites for installing the DataPower Nano Gateway subsystem
          • Installing a gateway API CRD for DataPower Nano Gateway
          • Deploying the DataPower Nano Gateway operator
          • Deploying Valkey Operator and Operand for DataPower Nano Gateway
      • Deployment procedures
        • Obtaining product files
          • Verifying the integrity of IBM product files
        • Deploying on Kubernetes
          • Deploying operators and cert-manager
            • Deploying operators in a single-namespace API Connect cluster
            • Deploying operators in a multi-namespace API Connect cluster
            • Customizing certificates during installation on Kubernetes
              • Generating custom certificates using cert-manager
              • Generating custom certificates manually
              • Deploying API Connect subsystems with custom certificates
          • Installing the API Connect subsystems
            • Installing the management subsystem
            • Installing the DataPower API Gateway subsystem
            • Installing the DataPower Nano Gateway subsystem on Kubernetes
            • Installing the webMethods API Gateway subsystem
              • Enabling HTTP on Port 5555 for webMethods API Gateway
              • Adding Integration Server (IS) Packages in webMethods API Gateway
            • Installing the webMethods API Gateway in a multi‑namespace environment
            • Installing the webMethods API Gateway in a multi‑cluster environment
            • Installing the CMS Portal subsystem
              • Defining multiple portal endpoints for a Kubernetes and OpenShift environments
            • Installing the analytics subsystem
              • Creating the analytics CR
              • Installing analytics
            • Installing the Federated API Management subsystem
            • Installing the Developer Portal subsystem
          • Troubleshooting installation on Kubernetes
        • Deploying on OpenShift and Cloud Pak for Integration
          • Configuring FIPS support on OpenShift
          • Preparing for installation
            • Operator, CASE, and platform requirements
            • API Connect configuration settings
              • Basic configuration settings
              • Management subsystem settings
              • Gateway subsystem settings
              • CMS Portal subsystem settings
              • Developer Portal subsystem setting
              • Federated API Management subsystem setting
              • Analytics subsystem settings
              • Additional Kubernetes settings
            • Configuring timeouts for management endpoints
          • Installation procedures with IBM Cloud Pak for Integration
          • Installing API Connect in a single namespace on OpenShift
            • Installing operators
            • Setting up a certificate issuer
            • Deploying individual subsystem CRs with automatic certificate management
            • Default issuers and automatic certificate management
            • Installing the management subsystem in a shared namespace
            • Installing the DataPower API Gateway subsystem in a shared namespace
            • Installing the DataPower Nano Gateway subsystem in a single namespace on OpenShift
              • Configuring wildcard routing for DataPower Nano Gateway on OpenShift
            • Installing the webMethods API Gateway in a shared namespace
              • Enabling HTTP on Port 5555 for webMethods API Gateway
            • Installing the CMS Portal subsystem in a shared namespace
            • Installing the analytics subsystem in a shared namespace
            • Installing the Federated API Management subsystem in a shared namespace
            • Installing the Developer Portal subsystem in a shared namespace
          • Installing API Connect subsystems in different namespaces or environments on OpenShift
            • Installing operators
            • Installing the management subsystem
            • Extracting the management ingress-ca certificates
            • Installing the DataPower API Gateway subsystem
            • Installing the webMethods API Gateway in a different namespace
              • Enabling HTTP on Port 5555 for webMethods API Gateway
            • Installing the CMS Portal subsystem
            • Installing the Developer Portal subsystem
            • Installing the analytics subsystem
            • Installing the Federated API Management subsystem in different namespaces
            • Installing the Developer Portal subsystem in different namespaces
          • Installing with the top-level CR on OpenShift
            • Installing operators
            • Installing API Connect
            • Configure the top‑level APIConnectCluster for v12 subsystem support
          • Air-gapped installation
            • Installing with a bastion host
            • Installing with a portable computer or storage device
          • Enable additional features post-install
            • Enable management CA verification on REST API calls
            • Enable JWT security and disable mTLS between subsystems
          • Troubleshooting installation on OpenShift
    • Upgrading API Connect
      • Upgrading on Kubernetes
        • Planning your API Connect upgrade on Kubernetes
        • Pre-upgrade preparation and checks on Kubernetes
        • Upgrading DataPower Operator and Operand independently of the APIC
        • Upgrading API Connect on Kubernetes
          • Upgrading the management subsystem on Kubernetes
          • Upgrading API Agent on Kubernetes
          • Upgrading the CMS Portal subsystem on Kubernetes
          • Upgrading the analytics subsystem on Kubernetes
          • Upgrading the Developer Portal subsystem on Kubernetes
          • Upgrading the Federated API Management subsystem on Kubernetes
          • Upgrading the gateway subsystem on Kubernetes
          • Upgrading the DataPower Nano Gateway subsystem on Kubernetes
          • Upgrading the webMethods API Gateway subsystem on Kubernetes
          • Migrating from Ingress to Gateway API on Kubernetes
        • Troubleshooting upgrades on Kubernetes
          • Enabling gateway peering and verifying cluster status
      • Upgrading on OpenShift and Cloud Pak for Integration
        • Planning your API Connect upgrade on OpenShift
          • Operator, CASE, and platform requirements for upgrading
        • Pre-upgrade preparation and checks on OpenShift
          • Resolving duplicate users before upgrade on Cloud Pak for Integration
          • Pre-upgrade preparation for air-gapped environment using a bastion host
          • Pre-upgrade preparation for air-gapped environment using a portable storage device
        • Upgrading API Connect on OpenShift
          • Upgrading the DataPower Nano Gateway subsystem on Red Hat OpenShift
        • Troubleshooting upgrade on OpenShift
    • Upgrading webMethods API Management products
      • Planning your upgrade
        • Single and multiple API Connect Cloud comparison
      • Working with webMethods upgrade tools
        • Installing and using apicupgrade CLI
          • Configuration options
          • Server certificate verification
        • Installing Transition helper tool
      • Upgrading Developer Portal
        • Data transition
      • Upgrading webMethods API Gateway
        • Data transition
          • Troubleshooting data transition upgrade issues
          • API Gateway events mapping
        • Management plane transition
          • Transitioning assets to API Manager
          • Deployment configurations
          • Troubleshooting assets transition issues
          • Supported assets for transition
          • Limitations
            • Manually updating plan and package icons after transition
      • Upgrading Federated API management
        • Data transition
        • Troubleshooting upgrade issues
      • Transferring IS packages
      • Mapping webMethods API Management functionalities to API Connect
      • Creating client certificates for TLCR deployments
    • Maintaining API Connect
      • Advanced configuration
        • Installing License Service
        • Installing the toolkit
        • Customizing user-facing certificates
        • Changing deployment profiles on Kubernetes and OpenShift
        • Changing deployment profiles on OpenShift top-level CR
        • Changing the deployment profile on Cloud Pak for Integration
        • Replica override for microservices
        • Enabling CMS Portal feature flags on Kubernetes
        • Enabling CMS Portal feature flags on OpenShift and Cloud Pak for Integration
        • Enabling UI feature flags on Kubernetes
        • Enabling UI feature flags on OpenShift and Cloud Pak for Integration
        • Advanced configuration for the management subsystem
          • Updating management subsystem password, keys, and secrets
            • Changing the cloud administrator password
            • Changing the database encryption key
            • Changing the registration client_id and client_secret for applications
          • Disabling portal-proxy container in the Management subsystem
          • Configuring maximum size of client requests to the Management subsystem
          • Setting rate limits for public APIs on the management service for a Kubernetes environment
          • Enabling API discovery on Kubernetes
          • Enabling governance on Kubernetes
          • Enabling API Agent for the management subsystem
          • Restarting the Management subsystem pods
          • Disabling the PodDisruptionBudget (PDB) for the management EDB database
          • Postgres database shutdown
            • Shutting down the Postgres database in the Management subsystem on different environments
            • Starting the Postgres database in the Management subsystem on different environments
          • Advanced configuration for Postgres components on Kubernetes
            • Configuring zone affinity in the management subsystem
          • Postgres database shutdown
            • Shutting down the Postgres database in the Management subsystem on different environments
            • Starting the Postgres database in the Management subsystem on different environments
          • Disabling the status feedback on products page
        • Advanced configuration for the analytics subsystem
          • Clean up indices after deployment mode change
        • Advanced configuration for the Federated API Management subsystem
        • Advanced configuration for the DataPower API Gateway subsystem
          • Customizing a DataPower API Gateway deployment
          • Updating the DataPower API Gateway password, secrets, and certificates
            • Changing the DataPower API Gateway administrator password
            • Changing the DataPower API Gateway client secret
            • Updating the DataPower API Gateway peering certificate
            • Updating the DataPower API Gateway director and invocation endpoint profiles
          • Overriding the default DataPower API Gateway image, version, and license
          • Overriding pod CPU and memory settings
          • Enabling autoscaling of DataPower API Gateway pods
          • Configuring rate limits on the DataPower API Gateway nodes
          • Dynamically re-registering and reconfiguring a Gateway service in a Kubernetes deployment
          • Overriding DataPowerService spec properties
        • Advanced configuration for the CMS Portal subsystem
          • Updating portal keys and secrets
            • Changing the secret for portal data and system tools
            • Changing the portal client_secret
        • Advanced configuration for the Developer Portal subsystem
          • Cleaning up Developer Portal before redeployment
      • Backing up, restoring, and disaster recovery
        • Backing up and restoring the management subsystem
          • Taking a management infrastructure configuration backup
          • Configuring management database backups
          • Running an on-demand backup of the management database
          • Restoring from a management database backup
            • Restoring the management database with a backup CR
            • Restoring the management database with a backup ID
          • Recovering from a disaster
          • Troubleshooting management database backup and restore
        • Backing up and restoring the CMS Portal
          • Taking CMS Portal infrastructure configuration backup
          • Configuring portal database backups
          • Running an on-demand backup of the portal database
          • Managing your remote portal database backups
          • Restoring from a portal database backup
          • Recovering from a disaster
          • Troubleshooting portal database backup and restore
        • Backing up and restoring the analytics subsystem
        • Backing up and restoring webMethods API Gateway subsystem
          • Backing up data with AWS S3
          • Restoring backed up data
          • Preparing webMethods API Gateway for disaster recovery
          • Recovering webMethods API Gateway after a disaster
        • Recovering Developer Portal subsystem after a disaster
        • Recovering Federated API Management subsystem after a disaster
        • Backing up and restoring on OpenShift top-level CR
          • Backing up your OpenShift top-level CR API Connect deployment
          • Disaster recovery on OpenShift top-level CR
        • Backing up and restoring on Cloud Pak for Integration and OpenShift top-level CR
          • Backing up your Cloud Pak for Integration API Connect deployment
          • Recovering from a disaster on Cloud Pak for Integration
      • Renewing TLS certificates
        • Renewing cert-manager controlled certificates
          • Renewing the management-ca with the ManagementSecretRotation CR
          • Renewing the portal-ca with the PortalSecretRotation CR
          • Renewing the Developer Portal CA
          • Renewing the analytics-ca with the AnalyticsSecretRotation CR
            • Renewing internal user credentials with AnalyticsSecretRotation CR
          • Renewing the analytics CA
          • Renewing the Federated API Management CA
          • Renewing the DataPower Nano Gateway CA
          • Renewing the webMethods API Gateway CA
          • Renewing the ingress-ca
            • Copying renewed ingress-ca to subsystems in different namespaces
          • Renewing end-entity certificates
          • Monitoring cert-manager certificate renewal
        • Renewing custom certificates
        • List of Issuers, CA certificates, and secrets
        • List of ingress certificates
        • List of intra-subsystem certificates
      • Monitoring and health checks
        • Monitoring on Kubernetes
          • Monitoring subsystems on Kubernetes
          • Monitoring Postgres disk usage
          • Monitoring platform health using Kubernetes events
        • Monitoring on OpenShift
          • Monitoring the API Connect cluster on OpenShift
          • Monitoring Postgres disk usage on OpenShift
          • Monitoring platform health on Red Hat OpenShift using Kubernetes events
        • Monitoring on Cloud Pak for Integration
          • Monitoring the API Connect cluster on Cloud Pak for Integration
          • Monitoring Postgres disk usage on Cloud Pak for Integration
        • Obtaining simple health check data of CMS Portal sites by using a REST API call
        • Monitoring subsystem health checks
      • Logging
        • Gathering logs
        • Changing logging levels
      • Troubleshooting
        • Power-cycling check on OpenShift and Cloud Pak for Integration
      • Configuring Horizontal Pod Autoscaler (HPA)
    • Uninstalling API Connect
      • Uninstalling API Connect subsystems
      • Removing API Connect
      • Removing API Connect on OpenShift or Cloud Pak for Integration
  • VMware
    • Planning your deployment
      • Prerequisite skills for administering API Connect on VMware
      • Deployment overview for endpoints
      • Planning your deployment topology and profiles
      • Enable JWT instead of mTLS
      • Firewall requirements on VMware
        • Firewall enabled ports for clustered OVA deployments
        • Load balancer ports for clustered OVA deployments
      • Load balancer configuration in a VMware deployment
      • Multiple data center deployment strategies
      • Planning your analytics deployment
      • API Connect TLS certificate best practices
        • Customizing your user-facing certificates
    • Installing API Connect
      • IBM API Connect Version 12 software product compatibility requirements
      • VMware deployment overview and requirements
      • API Connect licenses
      • Preparing to install API Connect in VMware
        • Verifying the integrity of IBM product files
      • Installing the management subsystem on VMware
        • Preparing the management subsystem for deployment
        • Deploying the management subsystem OVA
        • Verifying the management subsystem installation
      • Installing the analytics subsystem on VMware
        • Preparing the analytics subsystem for deployment
        • Deploying the analytics subsystem OVA
        • Verifying installation of the analytics subsystem
      • Installing the CMS Portal subsystem on VMware
        • Preparing the CMS Portal subsystem for deployment
          • Configuring two NICs on the portal
        • Deploying the portal subsystem OVA
        • Verifying installation of the portal subsystem
        • Defining multiple portal endpoints for a VMware environment
      • Installing the federated API management subsystem on VMware
        • Preparing the federated API management subsystem for deployment
        • Deploying the federated API management subsystem OVA
        • Verifying installation of the federated API management subsystem
      • Installing the Developer Portal subsystem on VMware
        • Preparing the Developer Portal subsystem for deployment
        • Deploying the Developer Portal subsystem OVA
        • Verifying installation of the Developer Portal subsystem
      • Installing the webMethods API Gateway subsystem on VMware
        • Preparing the webMethods API Gateway subsystem for deployment
        • Deploying the webMethods API Gateway subsystem OVA
        • Verifying the webMethods API Gateway subsystem installation
        • Adding IS packages to webMethods API Gateway on VMware
      • Deploying DataPower Gateway virtual appliance
        • Installing DataPower Gateway
        • Configuring DataPower Gateway for API Connect
          • Configuring DataPower API Gateway
          • Configuring DataPower Gateway (v5 compatible)
        • Best practices for enabling TLS in API Connect peer groups and managing certificate expiry
        • Sample configuration for multiple peering objects on gateway services external to Kubernetes
      • Post-deployment steps
    • Upgrading API Connect
      • Planning your API Connect upgrade on VMware
      • Pre-upgrade preparation and checks VMware
        • Control Plane files for earlier releases
      • Upgrading management, portal, and analytics on VMware
      • Upgrading DataPower Gateway
      • Troubleshooting upgrades on VMware
    • Upgrading webMethods API Management products to API Connect v12.1
      • Planning your upgrade
        • Single and multiple API Connect Cloud comparison
      • Working with webMethods upgrade tools
        • Installing and using apicupgrade CLI
          • Configuration options
          • Server certificate verification
        • Installing Transition helper tool
      • Upgrading Developer Portal on VMware
        • Data transition
      • Upgrading webMethods API Gateway on VMware
        • Data transition on VMware
          • Troubleshooting data transition upgrade issues on VMware
          • API Gateway events mapping on VMware
        • Management plane transition on VMware
          • Transitioning assets to API Manager on VMware
          • Deployment configurations on VMware
          • Troubleshooting assets transition issues on VMware
          • Supported assets for transition on VMware
          • Transition helper tool limitations on VMware
      • Upgrading Federated API management on VMware
        • Data transition
        • Troubleshooting upgrade issues
      • Transferring IS packages
      • Mapping webMethods API Management functionalities to API Connect
    • Maintaining API Connect
      • Advanced installation on VMware
        • Installing the IBM License Metric Tool on VMware
        • Installing the toolkit
      • Advanced configuration on VMware
        • Adding a static route on a virtual machine
        • Adding disk space to a VMware appliance
        • Appliance boot mode configuration
        • Running commands at boot with iso-ignored boot mode
        • Changing deployment profiles on VMware
        • Changing the DNS server configuration
        • Configuring API Connect subsystems in a cluster
        • Overriding NTP server configuration
        • Configuring SSHD to limit access to your deployment
        • Enabling CMS Portal feature flags on VMware
        • Specifying a range of allowable client IP addresses for the portal
        • Managing an appliance data disk
        • Replica override for microservices on VMware
        • Testing a new configuration against a current cluster
        • Changing the encryption secret for Developer Portal
        • Changing the encryption secret for webMethods API Gateway
        • TLS certificate concepts and operations
          • Certificate reference VMware
          • Customizing user-facing certificates
          • Certificate expiry and renewal
          • Extracting and copying certificates
          • Rotating the portal intra-subsystem certificates on VMware
          • Rotating internal Kubernetes certificates
          • Updating the gateway peering certificate
          • Apicup certs command reference
          • Certificate validation reference
        • Use JWT security instead of mTLS between subsystems
        • Credentials and encryption secrets reference
      • Advanced configuration for management subsystem
        • Setting rate limits for public APIs on the management service
        • Configuring maximum size of client requests to the Management subsystem on VMware
        • Enabling API discovery on VMware
        • Enabling governance on VMware
        • Enabling UI feature flags on VMware
        • Enabling API Agent for the management subsystem in VMware
      • Configuring rate limits on the gateway nodes on VMware
      • Backing up and restoring on VMware
        • Project directory backup
        • Backing up and restoring the management subsystem
          • Configuring management database backups
          • Running an on-demand backup of the management database
          • Restoring from a management database backup
          • Management subsystem disaster recovery
        • Backing up and restoring the portal subsystem
          • Configuring portal database backups
          • Running an on-demand backup of the portal database
          • Restoring the portal database backup
          • Portal subsystem disaster recovery
        • Backing up and restoring the federated API management subsystem
          • Configuring federated API management database backups
          • Running an on-demand backup of the federated API management database
          • Restoring the federated API management database backup
        • Backing up and restoring the Developer Portal subsystem
          • Configuring Developer Portal database backups
          • Running an on-demand backup of the Developer Portal database
          • Restoring the Developer Portal database backup
        • Backing up and restoring the webMethods API Gateway subsystem
          • Configuring webMethods API Gateway database backups
          • Running an on-demand backup of the webMethods API Gateway database
          • Restoring the webMethods API Gateway database backup
        • Backing up and restoring the analytics subsystem
        • Using VM snapshots for infrastructure backup and disaster recovery
        • Disaster recovery
      • Disabling and re-enabling the analytics subsystem on VMware
      • Monitoring and health checks
        • Checking cluster health on VMware
        • Monitoring Postgres disk usage on VMware
        • Obtaining simple health check data of CMS Portal sites by using a REST API call
        • Monitoring with SNMP
      • Logging
        • Configuring remote logging for a VMware deployment
        • Gathering logs in a VMware environment
        • Changing logging levels
      • Troubleshooting
        • Recreating a calico pod that is in the CrashLoopBackOff state
        • Running a filesystem check on a VMware root partition
        • Increasing the PostgreSQL archive_timeout on VMware
        • Dynamically re-registering and reconfiguring a Gateway service in a VMware deployment
        • Troubleshooting analytics on VMware
  • Migrating to a different form factor in v12
    • v12 migration overview
    • v12 migration requirements
    • v12 migration steps
      • Preparing the source system
      • Installing the target system on Kubernetes, Cloud Pak for Integration, and Open Shift
      • Installing the target system on VMware
      • Restoring the target system on Kubernetes, Cloud Pak for Integration, and OpenShift
      • Restoring the target system on VMware
      • Verifying the target system on Kubernetes, Cloud Pak for Integration, and OpenShift
      • Verifying the target system on VMware
    • Migrating from OpenShift to Cloud Pak for Integration on the same cluster
    • v10 migration troubleshooting
  • The API Connect operations tool: apicops
• Configuring and managing your server environment
  • Cloud Manager configuration checklist
  • Activating your Cloud Manager user account
  • Accessing the Cloud Manager user interface
  • Defining your Cloud Manager topology
    • Creating an availability zone
    • Registering a DataPower API Gateway service
    • Registering a DataPower Nano Gateway service
    • Registering a webMethods API gateway service
    • Registering an analytics service
    • Registering a CMS Portal service
    • Registering a Developer Portal service
    • Associating an analytics service with a gateway service
    • Associating an OpenTelemetry configuration with a gateway service
      • Creating an OpenTelemetry configuration
    • Setting visibility for a service
  • Managing authentication and security
    • User registries overview
      • Configuring an Authentication URL user registry
      • Configuring a shared custom user registry
      • Configuring an LDAP user registry in the Cloud Manager
        • Using the CLI to configure a shared LDAP user registry
      • Configuring a Local User Registry
      • Configuring an OIDC user registry in Cloud Manager
      • Setting visibility for a user registry
      • Deleting a user registry
      • Removing a user from a user registry
        • Removing yourself from a user registry
        • Removing another user from a user registry
    • TLS profiles overview
      • Creating a TLS server profile
      • Creating a TLS client profile
        • Defining elliptic curve cryptographic schemes for a TLS client profile
      • Creating a keystore
      • Creating a truststore
      • Managing TLS profiles, keystores, and truststores
      • Using OpenSSL to generate and format certificates
    • OAuth Provider overview
      • Configuring a native OAuth provider
        • Configuring basic settings for a native OAuth provider
        • Configuring scopes for a native OAuth provider
        • Configuring user security for a native OAuth provider
        • Configuring tokens for a native OAuth provider
        • Configuring token management and revocation for a native OAuth provider
        • Configuring introspection for a native OAuth provider
        • Configuring metadata for a native OAuth provider
        • Configuring the OIDC parameters for a native OAuth provider
        • Editing a native OAuth provider by using the API Editor
      • Configuring a third-party OAuth provider
        • Configuring scopes for a third-party OAuth provider
      • Setting the visibility for OAuth providers
      • OAuth concepts for API Connect
        • OAuth user scenario
        • OAuth introspection for third-party OAuth providers
        • Oauth metadata URL and authentication URL
        • Scope
        • Tokens
          • Refresh tokens
          • OAuth revocation URL
          • Authenticating and authorizing through a redirect URL
          • Token management with the DataPower Gateway (v5 compatible)
          • Token management with the DataPower API Gateway
        • Authentication URL
        • Custom forms for user security
          • Creating a custom HTML login form for user security
          • Creating a custom HTML authorization form for user security
        • Securing an API with a JSON Web Token
        • Troubleshooting OAuth
  • Configuring the cloud settings
    • Change the name of your cloud
    • Configuring an email server for notifications
    • Setting up notifications
      • Customizing email notification templates
    • Configuring invitation timeouts
    • Configuring API key settings
    • Using the CLI to modify cloud settings
    • Configuring Base64 encoding for temporary tokens
    • Configuring the password-reset notification and timeout
    • Selecting user registries for Cloud Manager and API Manager
      • Setting a default user registry for Cloud Manager and API Manager
    • Configuring timeouts for access tokens and refresh tokens
    • Viewing platform and UI endpoints
    • Configuring the default gateway services for Catalogs
    • Enabling Federated API Management service
    • Managing the public/private key pairs for signing tokens
      • Configuring public/private key pairs for tokens
  • Configuring governance in the Cloud Manager
    • The governance ruleset lifecycle in the Cloud Manager
    • Updating rulesets and rules with the toolkit CLI
  • Administering provider organizations
    • Creating a provider organization
    • Editing a provider organization
    • Deleting a provider organization
    • Viewing current provider organizations
    • Sending messages to provider organization owners
  • Administering members and roles
    • Creating roles in the admin organization
    • Editing roles in the admin organization
    • Configuring LDAP group mappings on Cloud Manager user roles
    • Deleting roles in the admin organization
    • Viewing members and roles
    • Adding members to the admin organization
    • Assigning roles to members
    • Deleting a member
    • Role Defaults overview
      • Managing role defaults for provider organizations
  • Monitoring the cloud
    • Accessing and configuring analytics
    • Configuring audit logging to monitor user operations
      • Configuring the audit settings
    • Reviewing processing status and downloading gateway logs
  • Changing your Cloud Manager password and profile information
  • Resolving login problems by increasing HTTP header size
  • Onboarding a new admin for Cloud Pak for Integration
  • Extending the Gateway server behavior
    • Gateway extension guidelines - DataPower Gateway (v5 compatible)
    • Gateway extension guidelines - DataPower API Gateway
      • Gateway extensions manifest
        • GWD extension type
          • config-sequence
          • parse-settings
          • analytics-endpoint
          • front-side-handler
          • apigw
          • tls-client
          • api-collection
          • api-plan
          • registry
          • oauth-provider
          • api-definition
          • assembly
        • CLI command file extensions
      • v5 policy emulation limitations
    • Configuring your Gateway server extensions
  • Cloud Manager Tutorials
    • Tutorial: Configuring the Cloud
    • Tutorial: Creating a Provider Organization
• Creating, deploying, and publishing APIs using API Agent
  • API Agent overview
  • API Agent user roles
  • Configuring
    • Managing on-premises dependencies
    • Watsonx.ai settings
    • API Agent settings
      • Setting trust for self-signed certificates
      • Setting trust for certificates on macOS
    • API Agent sources
      • API Connect catalogs and drafts
      • Application sources
      • Documentation files
    • Configuring MCP tools
    • Securing communication between the Visual Studio Code plug-in and API Connect
    • MTLS for connectivity pack applications
  • Getting started
    • Installing API Agent in Visual Studio Code
    • Logging in to API Agent in Visual Studio Code
    • Configuring API Manager connection
    • Uninstalling API Agent
  • Best practices
    • Starting a new session
    • Debugging process
    • Attaching and downloading files
  • Using API Agent
    • Searching APIs and tables
    • Creating an OpenAPI document from an existing source
    • Generating python code from an OpenAPI
    • Deploying application to IBM Code Engine
    • Creating, publishing, and validating an API
    • Using API Agent in IBM API Studio
  • Creating MCP server
    • Configuring MCP servers
    • Enabling the MCP server
  • API Agent tools
    • Tools compatibility
    • Management MCP
      • Project-related operations
      • API Manager operations
      • Consumer-related operations
      • List operations
      • Plans with multiple tool operations
    • Artifacts searcher
    • OAS Creator
    • OpenAPI to Python
    • Code deployment
    • Documentation searcher
    • Analytics
    • API discovery and rationalization
    • MCP server and client
    • Governance MCP
    • Management AI MCP
    • IBM API Studio
    • Help
  • Troubleshooting
  • Known limitations
  • Frequently Asked Questions
• Creating, deploying, and publishing APIs using IBM API Studio
  • Getting started
  • Installing IBM API Studio
    • Using IBM API Studio with self-signed certificates
  • Configuring IBM API Studio
    • Configuring projects folder
    • Configuring version control system
      • Connecting to VCS by using GitHub credentials
      • Connecting to VCS by using a Personal Access Token
      • Configuring multiple repositories
      • Disconnecting from repositories
    • Configuring webMethods API Gateway
    • Connecting IBM API Studio to API Manager
    • Configuring rulesets in IBM API Studio
    • Auto-subscribing to a plan of a published product
  • Using IBM API Studio
    • Creating API projects
    • Importing existing files
    • Importing existing API Studio project
    • Exporting API projects
    • Managing API projects in VCS
      • Creating branches in a VCS repository
      • Deleting branches in VCS repositories
      • Managing changes in a VCS API project
    • Defining kinds in IBM API Studio
    • Supporting asset types and lifecycle actions
    • Creating APIs
      • Creating APIs in code view
      • Creating APIs in form view
        • Creating REST APIs from scratch
        • Creating REST APIs by importing from file
        • Creating REST APIs by importing from URL
        • Creating SOAP APIs by importing from file
        • Updating API specification
        • API outline overview
    • Creating policies
      • Creating policies in code view
        • Working with policy sequence
      • Creating policies in form view
        • Creating a policy sequence
          • Adding policies to an API
      • Working with global policies
        • Creating global policies in form view
      • DataPower API policies
      • DataPower Nano Gateway API policies
        • Built-in policies
          • Cache
          • Circuit Breaker
          • Count Limit
          • Invoke
          • Invoke AWS Lambda
          • Load Balancer
          • Lua Script
          • Rate Limit
          • Retry
          • Set
          • Validate
          • Authenticate
          • Authorize
          • CORS
          • Extract Identity
          • IBM Cloud Login
          • Set Authorization
          • SQL Injection Filter
          • Block
          • Handlebars Template
          • Parse
          • Redact
          • Remove
          • Telemetry
          • Transform
          • Invoke Watsonx Models
          • Invoke Watsonx Tokenize
          • Invoke Watsonx Text Gen
          • Invoke OpenAI Chat Completions
          • Invoke OpenAI Embeddings
          • Invoke OpenAI Models ID
          • Invoke OpenAI Models
          • Invoke Azure OpenAI Chat Completions
          • Invoke Azure OpenAI Embeddings
          • Invoke Azure OpenAI Models ID
          • Invoke Azure OpenAI Models
          • Invoke Gemini Batch Embed Contents
          • Invoke Gemini Count Tokens
          • Invoke Gemini Embed Content
          • Invoke Gemini Generate Content
          • Invoke Gemini Models ID
          • Invoke Gemini Models
        • Logic constructs
          • If
          • Operation Switch
          • Return
          • Switch
          • Throw
          • Try
      • webMethods API Gateway policies
        • Transport
          • Inbound bulkhead
          • Set media type
          • Inbound messaging
          • URI Schemes
        • Identify and authorize
          • Identify and authorize
          • Authorize user
          • Set context variable
          • Messaging
          • External endpoint
        • Request processing
          • Request transformation
          • Data masking
          • Invoke webMethods IS
          • Set context variable
          • Validate API specification
          • Messaging
          • External endpoint
        • Traffic Monitoring
          • Log
          • Monitor traffic
          • Service result cache
          • Rate limiter
        • Routing
          • Invoke
          • Conditional routing
          • Content based routing
          • Dynamic routing
          • JMS/AMQP REST routing
          • Load balancer
          • Invoke webMethods IS
          • Set context variable
          • Set authorization
          • Outbound anonymous
          • Outbound Alias
          • Custom HTTP header
          • Messaging
          • External endpoint
          • AWS Lambda
        • Error Handling
          • Conditional error processing
          • Data masking
          • Invoke webMethods IS
          • Set context variable
          • Messaging
          • External endpoint
          • AWS Lambda
        • Response Processing
          • Response transformation
          • Validate API specification
          • Data masking
          • External endpoint
          • CORS
    • Working with API products and plans
      • Creating API products and plans in code view
      • Creating API products and plans in form view
        • Creating products in form view
        • Importing products in form view
        • Creating plans in form view
    • Creating asset versions
    • Staging projects
    • Publishing projects
    • Trying out an API
    • Mocking APIs
    • [Technology preview] Building MCP tools and server
      • [Technology preview] Creating MCP tools
    • Testing published APIs
      • Authoring tests in code view
        • Defining validation criteria using assertions in code view
        • Defining an environment configuration in code view
        • Supported assertions and syntax
      • Authoring tests from scratch in form view
        • Adding environment variables
        • Adding assertions
      • Authoring tests from OpenAPI specification
      • Running authored tests
        • Running authored tests by using UI
    • Using linting in IBM API Studio
      • AI linting support for API specifications
    • Viewing audit events
    • Using APIM CLI with IBM API Studio
      • Commands in APIM CLI
      • Build
      • Deploy
      • Test
      • Help
  • Troubleshooting VCS connection errors
• Developing APIs using Toolkit CLI
  • API development checklist
  • API discovery
    • Configuring a GitHub collector for API discovery
    • Configuring a DataPower API Gateway proxy collector for API discovery
    • Configuring Noname collector for API discovery
    • Configuring an OpenTelemetry collector for API discovery
    • Reviewing your discovered APIs
    • The API discovery lifecycle in API Manager
  • OpenAPI 3.1 support in IBM API Connect
  • Configuring plan rate limits for DataPower Nano Gateway with IBM API Studio
  • Working with the toolkit
    • Installing the toolkit
    • Using the developer toolkit command-line tool
      • Overview of the command-line tool
      • Logging in to a management server
      • Logging in to a management server with an OIDC registry
      • Cloud administration commands
      • API development and management commands
        • Configure user limit and invitation resend interval for Consumer organization
      • Creating APIs and applications
      • Publishing APIs and applications
      • Reading input from the command line
      • Scripting with the toolkit commands
      • Working with OpenAPI extensions
      • Using the toolkit CLI to execute API tests
        • Test definition syntax
        • Variable assignment in YAML configuration
  • Managing platform REST API keys
  • Working with API definitions
    • Securing your APIs
    • Defining security scheme components
      • Defining basic authentication security scheme components
      • Defining API key security scheme components
        • Client ID behavior in API key security definitions
      • Defining OAuth2 security scheme components
      • Defining OIDC security scheme components
      • Defining an HTTP bearer security scheme
    • Enforcing security requirements on an API
  • API properties
  • Variable references in API Connect
  • DataPower API policies and logic constructs
    • Built-in policies
      • Activity Log
      • Client Security
      • Extract
        • Constructing JSONata expressions to extract and transform data
      • GatewayScript
        • GatewayScript code examples
      • Gemini invoke
      • Generate JWT
      • GraphQL Cost Analysis
      • GraphQL Execute
      • GraphQL Introspect
      • IBM Cloud Authentication
      • Invoke
        • Configuring the Invoke policy for DataPower API Gateway
        • Configuring the Invoke policy for DataPower Gateway (v5 compatible)
      • JSON to XML
        • Configuring the JSON to XML policy for DataPower API Gateway
        • Configuring the JSON to XML policy for DataPower Gateway (v5 compatible)
      • Lambda
      • Log
      • Map
        • The Map policy structure
        • Configuring the Map policy in the user interface
        • Map policy examples
      • OAuth
        • Example - using multiple OAuth policies in an OAuth provider assembly
      • openai invoke
      • Azure openai invoke
      • Parse
      • Proxy
      • Rate Limit
        • Configuring a rate, burst, or count limit on the DataPower API Gateway
      • Rate Limit Info
      • Redaction - DataPower API Gateway
        • Constructing JSONata expressions to redact fields
      • Redaction - DataPower Gateway (v5 compatible)
        • Constructing XPath expressions to redact fields
      • Set Variable
        • Configuring the Set Variable policy for DataPower API Gateway
        • Configuring the Set Variable policy for DataPower Gateway (v5 compatible)
      • Token Mediation
      • User Security
      • Validate - DataPower API Gateway
      • Validate - DataPower Gateway (v5 compatible)
      • Validate JWT
      • Validate Username Token
      • watsonx.ai invoke
      • Websocket Upgrade
        • Configuring the Websocket Upgrade policy for DataPower API Gateway
        • Configuring the Websocket Upgrade policy for DataPower Gateway (v5 compatible)
      • XML to JSON
        • Configuring the XML to JSON policy for DataPower API Gateway
        • Configuring the XML to JSON policy for DataPower Gateway (v5 compatible)
      • XSLT
        • Configuring the XSLT policy for DataPower API Gateway
        • Configuring the XSLT policy for DataPower Gateway (v5 compatible)
        • XSLT policy examples
        • Implementation code examples
    • Logic Constructs
      • if
      • operation-switch
      • switch
        • Using the switch policy condition editor
      • throw
    • Using context variables in GatewayScript and XSLT policies with the DataPower API Gateway
      • Manipulating attachments in a message object
    • User-defined policies
  • Including elements in your API assembly
    • The assembly editor
    • Adding elements to your assembly
    • Handling errors in the assembly
  • Creating and validating API and Product definitions by using the CLI
    • Creating an OpenAPI definition file
      • IBM extensions to the OpenAPI specification
        • execute
          • activity-log
          • client-security
          • extract
          • gatewayscript
          • gemini-invoke
          • graphql-cost-analysis
          • graphql-execute
          • graphql-introspect
          • ibm-cloud-authentication
          • if
          • invoke
          • json-to-xml
          • jwt-generate
          • jwt-validate
          • log
          • map
          • operation-switch
          • oauth
            • Example - using multiple OAuth policies in an OAuth provider assembly
          • openai-invoke
          • Azure openai-invoke
          • parse
          • proxy
          • ratelimit
          • ratelimitinfo
          • redact - DataPower API Gateway
          • redact - DataPower Gateway (v5 compatible)
          • set-variable
          • switch
            • Writing switch condition scripts - DataPower API Gateway
            • Writing switch condition scripts - DataPower Gateway (v5 compatible)
          • throw
          • token-mediation
          • User-defined policies
          • user-security
          • validate - DataPower API Gateway
          • validate - DataPower Gateway (v5 compatible)
          • validate-usernametoken
          • watsonx-ai-invoke
          • websocket-upgrade
          • xml-to-json
          • xslt
        • catch
        • properties
        • catalogs
        • activity-log
        • finally
    • Specifying a gateway type for an API definition
    • Referring to an extension in an API definition
    • Using $ref to reuse code fragments in your OpenAPI files
    • Creating a Product definition file
      • Product definition schema
      • Completing the information section of your Product description
      • Specifying a gateway type for your Product
      • Converting a Product YAML file to use DataPower API Gateway
      • Specifying the visibility of your Product
      • Referencing the APIs for your Product
      • Describing Plans in your Product
      • An example YAML representation of a Product
    • Using x-ibm-languages to create multilingual API and Product documentation
    • Using x-example to control the examples displayed in the CMS Portal
    • Using x-embedded-doc to add additional documentation to products and APIs
    • Using x-pathalias to give consistent URLs for products and APIs
    • Validating the YAML or JSON definition of an API or Product
    • Creating and using API and Product definitions templates
  • Working with global policies
    • Customizing the preflow policies
  • Configuring TLS profile for gateways
    • Accessing TLS configuration
    • Creating a TLS server profile
    • Creating a TLS client profile
    • Creating a keystore
    • Creating a truststore
  • Configuring Server Name Indication (SNI)
  • Using the DataPower Nano Gateway to secure an application domain
    • DataPower Nano Gateway API assembly policies
      • Authenticate
      • Authorize
      • AzureOpenAiChatCompletions
      • AzureOpenAiEmbeddings
      • AzureOpenAiModels
      • AzureOpenAiModelsId
      • Block
      • cache
      • CircuitBreaker
      • SetAuthorization
      • Cors
      • CountLimit
      • ExtractIdentity
      • HandlebarsTemplate
      • IbmCloudLogin
      • If
      • Invoke
      • InvokeAwsLambda
      • LoadBalancer
      • LuaScript
      • Lua Script extension functions
      • OpenAiChatCompletions
      • OpenAiEmbeddings
      • OpenAiModels
      • OpenAiModelsId
      • OperationSwitch
      • Or
      • Parse
      • RateLimit
      • RetryIterator
      • Return
      • Redact
      • Remove
      • Set
      • SqlInjectionFilter
      • Transform
      • Switch
      • Throw
      • Try
      • UserDefined
      • Validate
      • WatsonxModels
      • WatsonxTextGen
      • WatsonxTokenize
      • GeminiModels
      • GeminiModelsId
      • GeminiGenerateContent
      • GeminiEmbedContent
      • GeminiBatchEmbedContents
      • GeminiCountTokens
    • Built-in JSONata functions supported by DataPower Nano Gateway
  • Reference
    • API Connect context variables
    • OAuth context variables
    • Error cases supported by assembly catches
• Managing your APIs
  • API management checklist
  • Activating your API Manager user account
  • Accessing the API Manager user interface
  • Using Engagement to automate notification tasks
    • Creating a notification task
    • Create scheduled reports
    • Engagement datasource
      • API events
      • Audit events
      • API summary
      • Config sync
      • Hearbeat
      • Metrics
  • Working with Catalogs
    • Creating and configuring catalogs
      • Additional catalog options
    • Managing simple aliases
      • Creating a simple alias at the catalog level
      • Creating a simple alias at the space level
      • Updating a simple alias
      • Deleting a simple alias
    • Managing HTTP transport security aliases for webMethods API Gateway
    • Configuring Product visibility at a Catalog or Space level
    • Managing Catalog membership
    • Importing a user-defined policy into a Catalog
    • Importing an OpenAPI extension into a Catalog
    • Retaining Version 5 vanity endpoint behavior in a Catalog
    • Protecting catalog properties
    • Porting APIs to DataPower Nano Gateway Using Porting Advisor
    • Integrating with Postman
      • Configuring Postman settings at the provider organization level
      • Enabling Postman integration for a catalog
      • Managing Postman collections through the product lifecycle
  • Creating a programming package
    • Modifying a programming package
  • Using Governance enforcement for validation
    • Configuring rulesets and enforcement type
    • Enabling governance enforcement to validate APIs and Products before publishing to a Catalog
  • Managing the application lifecycle
    • Approving application upgrade requests
  • Using syndication in API Connect
    • Enabling Spaces in a Catalog
    • Creating, modifying, and deleting Spaces
    • Working with Spaces
      • Managing Products in a Space
      • Managing subscription requests in a Space
      • Managing application subscriptions in a Space
      • Managing Space membership
      • Managing user access in a Space
      • Managing Gateways in a Space
  • Working with products
    • The product lifecycle
    • Managing your Products
      • Considerations when changing a product lifecycle with billing integration
      • Publishing a Product
        • Publishing a new Product
        • Replacing a Product with another Product
        • Superseding a Product with another Product
      • Migrating application subscriptions to another Product
      • Migrating application subscribers to new Product versions
      • Changing the availability of a Product
      • Deprecating a Product
      • Retiring a Product
      • Restaging a Product
      • Working with the subscriptions in a Product
      • Updating the gateway services for a Product
      • Removing a Product from a Catalog
      • Approving Product lifecycle and subscription requests
  • Working with APIs
  • Working with Plans
  • Working with consumer organizations
    • Creating a consumer organization
    • Editing a consumer organization
    • Deleting a consumer organization
    • Working with the applications in a consumer organization
    • Working with the subscriptions in a consumer organization
    • Working with consumer organization groups
    • Sending messages to consumer organization owners
  • Working with developer applications
  • Working with application subscriptions
  • Security and authentication
    • Creating a TLS client profile
      • Creating a keystore
      • Creating a truststore
      • Using OpenSSL to generate and format certificates
      • Viewing certificate details and adding certificates to a keystore or truststore
      • Defining elliptic curve cryptographic schemes for a TLS client profile
    • Authenticating by using your enterprise user registry
      • Working with user registries
        • Creating an Authentication URL user registry
        • Creating an organization-specific custom user registry
        • Creating an LDAP user registry in API Manager
          • Using the CLI to create an organization-specific LDAP user registry
        • Creating a Local User Registry
        • Creating an OIDC user registry in API Manager
      • Modifying the configuration details for a user registry
      • Password lockout criteria
    • Configuring a native OAuth provider
      • Configuring basic settings for a native OAuth provider
      • Configuring scopes for a native OAuth provider
      • Configuring user security for a native OAuth provider
      • Configuring tokens for a native OAuth provider
      • Configuring token management and revocation for a native OAuth provider
      • Configuring introspection for a native OAuth provider
      • Configuring metadata for a native OAuth provider
      • Configuring the OIDC parameters for a native OAuth provider
      • Editing a native OAuth provider by using the API Editor
    • Configuring a third-party OAuth provider
    • Configuring a JWT provider
    • OAuth concepts for API Connect
      • OAuth user scenario
      • OAuth introspection for third-party OAuth providers
      • OAuth external URL and authentication URL
      • Scope
      • Tokens
        • Refresh tokens
        • Token revocation
        • Authenticating and authorizing through a redirect URL
        • Token management with the DataPower Gateway (v5 compatible)
        • Token management with the DataPower API Gateway
      • Authentication URL user registry
      • Custom forms for user security
        • Creating a custom HTML login form for user security
        • Creating a custom HTML authorization form for user security
      • Securing an API with a JSON Web Token
      • Troubleshooting OAuth
  • API Analytics
    • Catalogs, spaces, and analytics
    • Accessing analytics
    • Analytics dashboards
  • Configuring governance in the API Manager
    • The governance ruleset lifecycle in the API Manager
    • Updating rulesets and rules with the toolkit CLI
    • Scanning your catalogs and spaces
      • Using the toolkit CLI to scan your catalogs and spaces
  • Administering user access
    • Setting the expiration for invitations
    • Configuring notifications
      • Configuring sender details for email notifications
    • Viewing your user information
    • Adding provider organization users and assigning roles
    • Creating custom roles
    • Removing a user from a provider organization
    • Configuring LDAP group mappings on API Manager user roles
    • User management
      • Adding users to your provider organization
        • Inviting users to your provider organization
        • Editing user roles in your provider organization
        • Viewing user profiles in your provider organization
      • Adding user groups to your provider organization
        • Editing user groups in your provider organization
        • Viewing user group profiles in your provider organization
        • Deleting user groups from your provider organization
      • Adding teams to your provider organization
        • Editing teams in your provider organization
        • Viewing team profiles in your provider organization
        • Deleting teams from your provider organization
    • Migrating users, groups, and teams from webMethods API Gateway
      • Configuring the local user registry for migration
      • Configuring the APIC Transition Helper for migration
      • Migrating assets with dependency resolution from webMethods API Gateway
      • Migrating individual assets from webMethods API Gateway
  • Changing your API Manager password
  • Resolving login problems by increasing HTTP header size
  • Reviewing processing status and downloading gateway logs
  • Reference
    • API gateway response codes
    • Troubleshooting your billing configuration
  • Using Config Sync to replicate catalog data
    • Downloading and extracting the API Connect Config Sync utility
    • Setting environment variables for Config Sync
    • Enabling encrypted LUR user data sync
    • Running Config Sync as a stand-alone binary
    • Running Config Sync as a cronjob on OpenShift
    • Running Config Sync as a cronjob on Kubernetes
    • Running Config Sync as a cronjob on VMware
• Authoring policies
  • Authoring policies for the DataPower Gateway (v5 compatible)
    • Describing your policy
    • Creating a new user-defined policy
      • Implementing your policy
    • Packaging and importing your policies into IBM API Connect
    • Reference
      • Implementation code examples
  • Authoring policies for the DataPower API Gateway
    • Defining, packaging and publishing a catalog-scoped policy for the API Gateway
      • Structure of the catalog-scoped user-defined policy YAML file
    • Defining, packaging, and publishing a global-scoped policy for the API Gateway
• Socializing your APIs using CMS Portal
  • Using the CMS Portal
    • Logging in as a consumer to the CMS Portal by using the CLI
    • Exploring APIs and Products in the CMS Portal
      • How to use a URL to navigate directly to a Product or API in the CMS Portal
      • Testing an API by using the CMS Portal test tool
      • Calling an API
        • Calling an API by using CORS
    • Applications in the CMS Portal
      • Registering an application
      • Upgrading a Development application to Production status
      • Managing applications
      • Editing an application
      • Deleting an application
      • Changing an application image
      • Verifying an application client secret
    • Analytics in the CMS Portal
      • Application analytics in the CMS Portal
      • Organization analytics in the CMS Portal
    • Consumer organizations in the CMS Portal
      • Adding a Consumer organization from within the CMS Portal
      • Editing the name of a Consumer organization
      • Switching Consumer organizations
      • Adding users to a Consumer organization
      • Removing a user from a Consumer organization
      • Changing the ownership of a Consumer organization
      • Deleting a Consumer organization
    • User accounts, passwords, and support in the CMS Portal
      • Creating a new developer account
      • Changing your account settings
      • Deleting your developer account
      • Configuring the terms of service in the subscription wizard
  • Configuring the CMS Portal site
    • Concepts in the CMS Portal
    • Getting started configuring the CMS Portal site
    • Enabling the IBM API Catalog module in the CMS Portal
    • Appearance
      • Controlling general appearance elements in the CMS Portal
        • Changing the shortcut icon
        • Changing the site email address
        • Changing the site logo
        • Changing the site name or site slogan
        • Changing the visibility of site branding
      • Adding custom JavaScript to a custom theme
      • Applying a modified content type template
      • Creating a sub-theme
      • Installing additional themes
      • Deleting themes
    • Content
      • Adding content elements in the CMS Portal
        • Adding and configuring meta tags
          • Disabling external search engine indexing
        • Adding custom pages
        • Integrating Blue Sky data into the social block
          • Editing the social block
        • Adding content in multiple languages
        • Adding custom pages to APIs and Products
        • Adding new frequently asked questions
        • Applying an image to an API or Product
        • Attaching a documentation file to APIs
        • Configuring blogs
        • Configuring the taxonomy menu block
        • Customizing the URL alias for a specific API or Product page
        • Embedding multimedia in site content
        • Linking from one piece of site content to another
        • Linking to social media sites
        • Managing tags in the CMS Portal
          • Tagging APIs based on their lifecycle phase
        • Adding images to site content
      • Configuring and restricting content in the CMS Portal
        • Creating content types
          • Adding fields to content types
        • Configuring documentation upload limitations
        • Configuring image upload limitations
        • Configuring the appearance of ratings in the CMS Portal
        • Customizing the privacy policy statement
        • Customizing the terms of use statement
        • Editing a site comment
        • Editing sample content
        • Editing tags for a specific item
      • Turning content on or off in the CMS Portal
        • Deleting a site comment
        • Deleting blocks
        • Disabling blogs
        • Deleting forums from the front page
        • Turning comments for specific content types on or off in the CMS Portal
        • Turning comments off for an individual item
        • Turning off ratings for specific content types in the CMS Portal
    • Structure
      • Configuring the front page
        • Disabling blogs
        • Deleting forums from the front page
      • Adding a menu
      • Adding and changing the blocks displayed on CMS Portal pages
      • Changing the front page banner block
      • Changing the front page Featured Content block
      • Changing the case studies content block on the front page
      • Changing the items in the main menu
      • Changing the ratings display
      • Displaying APIs and Products in categories
        • Enabling dynamic category creation
      • Implementing an image carousel
      • Making your application's image public
      • Providing navigation by tag hierarchy
      • Using the Views module in the CMS Portal
        • Creating views in the CMS Portal
        • Configuring the search results view in the CMS Portal
        • Configuring the default number of items in a view list in the CMS Portal
    • Configuration
      • Configuring content moderation
        • Editing, reviewing, and publishing moderated content
      • General configuration tasks
        • Adding a page load progress indicator
        • Adding custom fields to user records
        • Checking the site status report
        • Clearing the server caches
        • Configuring a proxy
        • Configuring the visibility of analytics in the CMS Portal
        • Configuring the API details visibility for non-authenticated users
        • Configuring API product recommendations
        • Adding a case study
          • Configure the case study module
        • Configuring the Run in Postman button in the CMS Portal and Consumer Catalog
        • Configuring cron to run scheduled tasks
        • Configuring search indexes and servers
        • Configuring the date and time
        • Configuring the notifications event log settings
        • Configuring the application settings
        • Configuring the site default time zone
        • Configuring the site error handling
        • Configuring which buttons are displayed in the WYSIWYG rich text editor
        • Configuring which languages are available
        • Customizing user account settings
        • Disabling languages
        • Disabling test tool restrictions
        • Enabling a cookie compliance banner
        • Enabling code languages for code snippets
        • Enabling code snippets for SOAP APIs
        • Forcing new users to accept terms and conditions
        • Hiding the admin registry on the login form
        • Hiding the certificate in the header for APIs secured with mutual TLS
        • Importing and exporting taxonomies
        • Removing keys beginning with x-ibm from Open API document download
        • Restricting access by IP address
        • Restricting or preventing access from search engines
        • Toggling the site in and out of maintenance mode
        • Viewing available updates
      • Managing CMS Portal security
        • Configuring CAPTCHA
        • Configuring reCAPTCHA
        • Configuring session timeout and limit
        • Configuring the timeout length for the password reset link
        • Configuring your site password policy
        • Disabling CORS warnings
        • Disabling live testing of APIs
        • How to enable penetration testing, and information about CMS Portal cookies
        • How to manage IP security in the CMS Portal
        • Managing banned IP addresses
        • Using flood control for login security
        • Login security
        • Using the Security kit
        • Using Honeypot for spam protection
    • People
      • Blocking and unblocking specific users
      • Controlling access to CMS Portal content
      • Creating a developer account to customize API properties
      • Email Subscribers
        • Emailing all subscribers
        • Emailing API subscribers
        • Emailing plan subscribers
        • Emailing product subscribers
        • Emailing consumer organizations
        • Token reference
      • How to style the CMS Portal emails
      • Working with roles in the CMS Portal
        • Creating administrator users for the CMS Portal
        • Assigning users to a role
        • Assigning permissions to a role
        • Creating a new role
    • Forums
      • Creating a new forum
      • Creating new forum containers
      • Configuring the creation of new forums for each API
      • Locking forum topics
      • Marking content in a forum as sticky
      • Removing forum posts
      • Turning off forums in the CMS Portal
    • Reports
    • Extend
      • Custom module development: an introduction to Drupal tools for PHP development
      • Custom module development: background and prerequisites
      • Custom module development: creating a module skeleton
      • Custom module development: using hooks
      • Installing custom modules
      • Deleting custom modules
      • Disabling modules
      • Using CMS Portal metadata on API Manager
      • Using a custom module for payment method creation
  • Managing the CMS Portal by using the toolkit CLI
    • Getting started with the Portal CLI commands
    • CMS Portal CLI commands
      • Using the api commands
      • Using the apic-config commands
      • Using the application commands
      • Using the backups commands
      • Using the consumer-org commands
      • Using the content commands
      • Using the custom-module commands
      • Using the custom-theme commands
      • Using the custom-translation commands
      • Using the custom-webserver-page commands
      • Using the drupal-config commands
      • Using the drupal-state commands
      • Using the entity commands
      • Using the export-entity commands
      • Using the factory-reset command
      • Using the forums commands
      • Using the ip-security-enabled command
      • Using the maintenance commands
      • Using the memcache commands
      • Using the modules commands
      • Using the php-memory commands
      • Using the platforms commands
      • Using the product commands
      • Using the queue commands
      • Using the role commands
      • Using the security command
      • Using the service command
      • Using the service-ip-allowlist commands
      • Using the site commands
      • Using the site-config commands
      • Using the sites commands
      • Using the themes commands
      • Using the twig commands
      • Using the user commands
    • Scenarios that use the Portal CLI
      • Exporting and importing custom themes and site configuration
        • Exporting and importing custom themes and site configuration by using the Portal Admin API
      • How to enable and disable maintenance mode on your CMS Portal
  • Troubleshooting guide for the CMS Portal
  • How to find your custom modules and themes on your CMS Portal
    • Preparations for upgrading your CMS Portal to Drupal 11
    • Upgrading to class-based hooks in Drupal 11
  • CMS Portal – Frequently Asked Questions
  • CMS Portal tutorials
    • Tutorial: Creating the CMS Portal
    • Tutorial: Creating a private CMS Portal site
    • Tutorial: Creating Accounts and Applications on the CMS Portal
    • Tutorial: Creating a custom theme for the CMS Portal
    • Tutorial: Using avatars
    • Tutorial: Using image optimization
    • Tutorial: Adding a Back to top button
    • Tutorial: Creating a drop-down menu link
    • Tutorial: Displaying blog posts on the front page
    • Tutorial: Displaying tweets on the front page
    • Tutorial: Changing the front page of your CMS Portal
    • Tutorial: Grouping products by category
    • Tutorial: Adding a field to the sign-up form
      • Tutorial: Adding validation to a field on the sign-up form
    • Tutorial for Adding a field group to group fields in a content type
    • Tutorial: Adding a custom block to the front page
    • Tutorial: Adding a custom block to a page other than the front page
    • Tutorial: Configuring the RobotsTxt file
    • Tutorial: Configuring the SecurityTxt file
    • Tutorials for using custom modules in the CMS Portal
      • Tutorial: Changing the profile page to display firstname lastname, instead of username
      • Tutorial: Adding validation to a field on the sign-up form
      • Tutorial: Installing the IBM secure authentication module
    • Tutorial: Using a custom weighting sort order on the product list page
    • Tutorial: Synchronizing application credentials from the CMS Portal with an external server
• Socializing your APIs using Consumer Catalog
  • Consumer organization lifecycle flow
    • Creating a new consumer organization
    • Editing the title of the consumer organization
    • Deleting a Consumer organization
    • Transferring the ownership of the consumer organization
  • Managing the members and invitations in the Consumer organization
    • Inviting a member to your consumer organization
    • Changing the role of an active member in your consumer organization
    • Resending a pending invitation
    • Deleting a member or invitation from your consumer organization
  • Reviewing analytics data of the consumer organization
  • Accessing Consumer Catalog using multiple user registries
    • Accessing the Consumer Catalog using Auth URL
    • Accessing the Consumer Catalog using LDAP
    • Accessing the Consumer Catalog using Local User Registry
    • Accessing the Consumer Catalog using OIDC
• Using the API Connect Backstage plug-in
  • Enabling the API Connect plug-in on Backstage
  • Enabling the API Connect plug-in on Red Hat Developer Hub
• Monitoring your API usage by using Analytics
  • Key concepts of API Connect analytics
  • Preinstallation planning
    • Estimating storage requirements
    • Kubernetes and Red Hat OpenShift preinstallation planning
    • VMware preinstallation planning
  • Managing your analytics subsystem
    • API Connect on VMware
      • Extra values file reference
    • API Connect on Kubernetes, Cloud Pak for Integration, and Red Hat OpenShift
      • Analytics CR properties reference
    • OpenSearch nodes, indices, shards, and replicas
  • Installing the analytics subsystem
  • Backup, restore, and disaster recovery
    • Kubernetes, Cloud Pak for Integration, and OpenShift
      • Taking an analytics infrastructure configuration backup
      • Configuring analytics database backups
        • Creating the object-store CA certificates
        • Limiting the number of analytics backups displayed by the AnalyticsBackup custom resource
      • Running an on-demand analytics database backup
      • Restoring the analytics database
      • Recovering from a disaster
      • Deleting old backups
      • Troubleshooting backup and restore
    • VMware
      • Backing up your analytics subsystem
        • Creating the object-store CA secret
      • Running an on-demand database backup
      • Restoring an analytics database backup
      • Recovering from a disaster
      • Troubleshooting backup and restore on VMware
  • API event record field reference
  • Summary API event record field reference
  • Advanced configuration options
    • Dedicated storage and scaling up
      • Horizontal scaling of storage pods
    • Retention and rollover
    • Logstash persistent queue
    • Offload to third-party systems
      • Configuring offload on Kubernetes and Red Hat OpenShift
        • Configuring offload server certificates on Kubernetes and Red Hat OpenShift
        • Configuring offload client certificates on Kubernetes and Red Hat OpenShift
      • Configuring offload on VMware
        • Configuring offload server certificates on VMware
        • Configuring offload client certificates on VMware
      • Sample output plug-ins for offloading data
      • Using offloaded analytics data to train AI models
      • Troubleshooting offload
    • Disable local storage
    • Shutting down the analytics subsystem
    • Restarting analytics pods
    • Enable Amazon SNS for Engagement
    • Changing deployment profile
      • Changing deployment profile on Kubernetes and Red Hat OpenShift
      • Changing deployment profile on VMware
    • Configuring TLS validation mode for engagement destinations
    • Performance tuning with ingestion pipeline properties
  • Customize your analytics data
    • Activity log policy
    • Customizing data with a gateway script or set-variable operation
    • Customizing data with ingestion filters
      • Kubernetes and Red Hat OpenShift individual subsystem installations
      • Cloud Pak for Integration and OpenShift top-level CR
      • VMware
      • Example ingestion filters
  • Accessing analytics in the DataPower Interact Gateway UI
    • API Connect UIs
      • Accessing analytics in the Cloud Manager UI
      • Accessing analytics in the API Manager UI
      • Accessing analytics in the CMS Portal
      • Accessing analytics in the Consumer catalog
      • Accessing analytics in the Developer Portal
    • AI insights and analysis for analytics
    • Counting total API calls for your analytics service
    • Export your analytics data
    • Allowing API Connect cloud admin users to view provider organization analytics data
    • Sharing analytics data for API discovery
    • Analytics CLI
    • Analytics REST API
      • Using the events scroll operation to export analytics data
  • Frequently Asked Questions
  • Troubleshooting analytics
    • No analytics data in UIs
    • Running out of storage space
    • Offload failure
    • Gathering postmortem logs
    • Analytics subsystem CR is in an error state
• Using webMethods API Gateway
  • API Gateway overview
    • Limitations and changes
  • Getting started
    • 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 the imported SOAP API by using SOAPUI
      • Testing the imported SOAP API by 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
    • Publish an API to Developer Portal
    • Monitor your API
      • Monitoring API-specific Analytics
      • Monitoring API Gateway-wide analytics
    • Debug an API
    • API Mocking
    • Authenticate an API by using API key
    • Set rate limits to APIs
      • Testing the API rate limit
    • Log API transactions
    • Request and response transformation
      • Transforming E-commerce API request header
      • Transforming response message
      • Testing request and response transformation policies
    • Configure global policies
    • Use routing policies
    • Validate API Specification
  • Administering
    • Deployment configuration
      • Supported environment variables
      • Troubleshooting tips: wmAPIGateway Package
      • Connecting webMethods API Gateway to Federated API Management
        • Federated API Management agent configuration
        • Federated API Management agent properties
        • Federated API Management agent configuration using properties
        • Federated API Management agent configuration using YAML file
        • Connecting API Gateway to Federated API Management using API Gateway UI
        • Logger Configuration
        • Example: Usage scenarios of connecting containerized API Gateway to Federated API Management using properties
        • Example: Usage scenarios of connecting non-containerized API Gateway to Federated API Management using properties
    • Administering API Gateway
      • General administration configuration
        • 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
          • Configuring the approval process for ownership change of assets
          • Email templates variable
          • Managing approval requests
        • Configuring proxy server alias
        • Adding a proxy bypass
        • URL aliases
          • Creating URL alias
          • Adding port mapping to URL alias
          • Enabling partial matching of URL aliases
        • Configuring custom content-types
        • Configuring application log levels
        • Configuring API callback processor settings
        • Messaging
          • Creating a JNDI provider alias
          • Creating a JMS connection alias
          • Updating JMS triggers
        • Web services endpoint alias
          • Creating an endpoint alias for a provider web service descriptor
          • Creating an endpoint alias for a consumer web service descriptor
      • Destination configuration
        • Configuring API Connect Analytics service for webMethods API Gateway communication
        • Configuring audit events for webMethods API Gateway destination
        • Configuring Developer Portal destination
          • Troubleshooting tips: Developer Portal destination
        • Configuring events for Developer Portal destination
        • Configuring Federated API Management
        • Configuring CentraSite destination
        • Configuring events for CentraSite destination
        • Configuring OpenSearch destination
          • Troubleshooting tips: OpenSearch destination
        • Configuring events for OpenSearch destination
        • Configuring Email destination
          • Configuring email templates
        • Configuring SNMP destination
        • Configuring events for SNMP destination
        • Custom destination
          • Publishing data to an external endpoint using custom destination
          • Publishing API-specific traffic monitoring data to a custom destination
          • Publishing data to an Integration Server service using custom destination
          • Publishing data to an AWS Lambda function using custom destination
          • Publishing data to a message queue using custom destination
        • Troubleshooting tips: API Gateway - Developer Portal integration
      • Audit logging
        • Configuring audit logs
      • SAML single sign-on
        • Enabling SAML SSO in API Gateway
        • Troubleshooting tips: SSO configuration
      • Configuring external accounts
        • Adding a service registry
        • Configuring an AWS alias
        • Configuring Integration Server instance for API implementation
      • Configuring admin password
      • Changing master password after deployment
      • 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
            • Runtime events and metrics data model
              • API Gateway
              • Developer Portal
              • Audit Log
              • CentraSite
              • OpenSearch
              • Email
              • JDBC
              • Local Log
            • Troubleshooting: Monitoring API Gateway
            • Generating thread memory dump
            • Generating heap dump
            • Causes for timeout errors
            • Monitoring OpenSearch
              • Application metrics
              • Infrastructure metrics
                • Container metrics
        • Troubleshooting tips: Monitoring performance
    • Overview of security configuration in API Gateway
    • Keystore and truststore
      • Configuring keystore information
      • Configuring truststore information
      • Configuring keystore and truststore information for inbound messages
      • Configuring keystore and truststore information for outbound connections
    • 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
    • Adding a SAML issuer
    • Custom assertions
      • Creating a custom assertion
      • Example: Custom assertions
    • Kerberos settings
      • Configuring API Gateway to use Kerberos
    • OAuth, JWT, and OpenID configuration
      • Configuring the internal authorization server
      • Adding a provider
      • Adding an external authorization server
      • Defining 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
      • 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
    • Performance tuning and scaling
      • Hardware and product configurations
      • Product configurations guidelines
      • Changing the JVM heap size to tune API Gateway performance
    • Removing user data
  • Managing
    • APIs
      • Define and manage APIs
        • Creating an API by importing an API from a file
        • Creating an API by importing an API from a URL
        • API creation from scratch
          • Creating a REST API from scratch
          • Creating a WebSocket API from scratch
          • Handling APIs of larger size
        • 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
        • 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
        • Adding tags to an API
        • Creating new API version
        • Deleting APIs
        • CentraSite provided APIs
        • API Manager provided APIs
      • API implementation
        • API mocking
          • Enabling API mocking
        • Consumer applications
          • Creating an application
          • Registering an API with consumer applications
        • API-level policies
          • Transport
            • Enable Bulkhead
            • 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 through external ports
                • Defining multiple OAuth 2.0 scopes in API Gateway
                • Retrieving OAuth token
              • JWT authentication use case and workflow
                • Retrieving JWT token
                • Retrieving JWT token with claim
              • OpenID authentication use case and workflow
              • Secure API using OAuth2 with refresh token workflow
                • Configuring OAuth2 authentication with refresh token
                • Refresh token process flow
                • Getting the access token with resource owner permission
                • Getting the access token without resource owner permission using refresh token in the subsequent attempts
              • Securing access token calls with PKCE
                • Enforcing PKCE globally
                • Securing the access token with Authorization Code (With PKCE) grant type using postman
                • Securing the access token by directly calling API Gateway's REST APIs
                • Enforcing PKCE selectively for each access token call
                • Generating 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
            • Invoking an API through HTTP or HTTPS using custom extension
            • Invoking an IS Service using a custom extension
            • Invoking an AWS Lambda function using custom extension
            • Invoking an API asynchronously through JMS/AMQP using a custom extension
            • Defining a custom variable
            • Custom extension properties
            • Data objects and variables available in API Gateway
          • Request and Response Transformation Policies
            • Transforming a request using Request Transformation policy
            • Request Transformation Policy properties
            • Transforming a request and its response using Transformation policy?
            • Response Transformation policy properties
          • Invoke webMethods IS Policy
            • Transforming a request using Invoke webMethods IS policy
            • Invoke webMethods IS policy properties for request processing
            • Transforming a response using Invoke webMethods IS policy?
            • Invoke webMethods IS policy properties for response processing
          • System Context Variables
          • The API for Context Variables
        • Global policies
          • Creating a global policy
          • Refining the scope of a global policy
        • Scope-level policies
          • Creating an API Scope
          • Creating a scope-level policy
        • Aliases
          • Creating a simple alias
          • Creating a Secure 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
        • Example: Usage Scenarios of API Scopes
        • Policy templates
          • Creating a policy template
          • Applying a policy template on the API details page
        • Change ownership of assets
          • Changing the ownership of an API
          • Change the ownership of an Application
          • Changing the ownership of multiple assets
        • Debugging API
          • Enabling tracing
          • Filtering runtime requests
          • Viewing trace details
          • Inspecting failed runtime requests
          • Importing runtime requests
          • Exporting or downloading runtime requests
        • API Mashups
          • Creating an API Mashup
        • SOAP to REST transformation
          • Activating SOAP to Rest transformation
          • Modifying the REST definitions for SOAP operations
          • Support for SOAP headers and body mapping
          • Supported Content-types and Accept Headers
          • REST API Endpoints
          • Samples for REST request
        • API First implementation
          • API First implementation using Integration Server
          • API First implementation using a third-party server
          • List of parameters used in API implementation
      • 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
          • Defining API-specific gateway endpoints?
          • Defining global gateway endpoint?
        • Publishing APIs to Developer Portal
        • Publishing APIs to service registries
        • Publishing APIs to Integration Server
      • Manage Packages and Plans
        • Packages and Plans
        • Creating a package
        • Creating a plan
        • Publishing a package
      • Monitor APIs
    • Users, groups, and teams
      • Adding a User
      • User groups
        • Adding a Group
        • API Gateway functional privileges
      • Team Support
        • Enabling Team Support
        • Creating teams
        • Assigning teams during asset creation
        • Assigning teams using team assignment rule
        • Modifying teams assigned to an API
        • 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 login and accessibility to 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
    • Promotions and stages
      • Promoting assets using promotion management API
      • Promoting assets from API Gateway user interface
        • Viewing promotion list and promotion details
        • Adding a stage
        • Repromoting assets
        • Rolling back asset promotions
        • Viewing rollback list and rollback details
      • Export and import assets and configurations
        • Exporting APIs
        • Importing asset and configuration archives
        • Troubleshooting tips: Import and export assets
    • Accessibility profiles
  • Reference
    • Administration APIs
      • API Gateway administration
      • Alias management
      • Application management
      • Approval management
      • API Gateway archive
      • API Gateway availability
      • Data management
      • Document management
      • Internal service
      • Package and Plan Management
      • Policy management
      • Port management
      • Promotion management
      • Public services
      • API Gateway search
      • Server information
      • Service management
      • Transaction data
      • User management
      • Backward compatibility support for REST APIs
      • Troubleshooting tips: REST APIs
    • Example: Managing an API
    • Example: Usage Scenarios of URL Aliases
• Using Federated API Management
  • Overview
  • Getting Started
    • Installing and accessing federated API management
    • Connecting Runtimes
      • Connecting API connect runtimes
        • Deployment considerations for connecting API Connect runtimes
        • Establishing cross-cluster communication with Federated API Management
      • Connecting Amazon API Gateway
        • AWS agents core implementation logic
        • Co-relation between Amazon API Gateway and federated API management terminologies
        • Deploying the AWS Agent in Docker
          • Authentication for AWS agent implementation
        • AWS Lambda Implementation Overview
          • Deploying AWS agent in AWS Lambda functions
            • Environment variables applicable for Lambda functions
      • Connecting Azure API Management Service
        • Azure agents core implementation logic
        • Co-relation between Azure API Management Service and federated API management terminologies
        • Deploying the Azure Agent in Docker
        • Deploying Java Function in Azure that uses Azure CLI
          • Environment variables applicable for Azure API Management Service
      • Connecting Apigee API Management
        • Co-relation between Apigee API Management and federated API Management terminologies
        • Deploying the Apigee Agent in Docker
      • Connecting Kong Gateway
        • Co-relation between Kong Gateway and federated API management terminologies
        • Deploying the Kong Gateway Agent in Docker
      • Connecting Third-party Gateway
  • Administering
    • Federated API management components
    • Configuration Details
    • Monitoring endpoints in Federated API management
    • User Management
      • Manage Users
        • Adding a user
      • Password Management
        • Resetting Password
      • User Profile
        • Modifying Profile Settings
  • Managing runtimes
    • Runtimes overview
  • Managing data planes
    • Data planes overview
  • Managing APIs
  • Monitoring
    • Monitoring overall performance of assets
    • Monitoring performance of data planes
      • Metrics of data planes
    • Monitoring performance of runtimes
      • Metrics of runtimes
    • Monitoring performance of APIs
      • Metrics of APIs
    • Setting display preferences and thresholds
  • Developing agents
    • Agent overview
    • Agent implementation approaches
    • Agent deployment modes
    • Agent SDK compatibility matrix
    • Implementing agents for third-party gateways
      • Accessing the Agent SDK
      • Agent SDK interfaces and classes
      • Creating agents by using SDK
      • Building Gradle projects
      • Deploying agents in Docker
  • Administration APIs
• Using Developer Portal
  • Overview
  • Configuring
    • Configuring SMTP settings
    • Configuring password policy
    • Specifying Developer Portal URL for reference from external systems
    • Specifying Cross-Origin Resource Sharing (CORS) URLs
    • Updating Developer Portal license
    • Configuring default group and group and community for new users
    • Configuring the default language
    • Configuring personal profile settings
    • Externalizing configurations
    • Developer Portal security configuration
      • Securing Developer Portal and OpenSearch communication
      • Securing communication between Developer Portal nodes in a cluster
      • Securing Developer Portal and webMethods API Gateway communication
      • Securing Developer Portal and Federated API Management communication
  • Administering
    • Security settings
      • Specifying multi-factor authentication settings
      • Specifying advanced security settings
    • Specifying user session settings
    • Specifying email notification templates
      • Email notification templates in Developer Portal
    • Configuring webhooks
      • Events for webhooks
    • Configuring webhooks to notify user requests to external approval systems
      • External approval system configuration
    • Configuring Federated API Management communication
    • Viewing audit log events
    • Configuring payment gateway
    • Adding payment details for consumers
    • Data backup and restore
      • Performing a data backup
        • Setting backup limit
      • Restoring data from a backup file
    • High availability configuration
      • Configuring high availability
    • Developer Portal ports configuration
      • Ports configuration
      • Configuring keystore
      • Disabling HTTPS port
      • Directing requests to HTTPS port
    • Configuring Developer Portal communication with secured webMethods API Gateway
    • Configuring access token signature validation
    • Restricting the HTTP port access
    • Docker support
      • Generating Docker image from installation
      • Running the Developer Portal Docker image
  • Customizing
    • Creating themes for customizing UI
    • Customize pages
      • Customizing blocks
        • Customization fields
      • Adding blocks and components
      • Moving blocks
      • Removing blocks
      • Adding pages
        • Assigning access to custom pages
    • Customize UI components
      • Adding new item to navigation bar
      • Customizing navigation bar
      • Customizing Sign up page
      • Customizing API grid
      • Customizing Package grid
      • Customizing API details pane
      • Customizing Plans grid
      • Adding language switcher icon
    • Customize labels
      • Adding new UI labels
    • Customize color schemes
      • Customizing color schemes
      • Customizing browser header text and icon
    • Customization by using web components
      • Registering web components
  • Managing
    • Managing users
      • User onboarding
      • Native registration
        • Adding users
        • Adding user groups
        • Inviting users to sign up
        • Assigning user privileges
        • Disabling user registration from the Sign up page
        • Onboarding strategy
          • Configuring user onboarding strategy
          • Configuring internal onboarding approval workflow
          • Approving user onboarding requests
      • Onboarding LDAP users and groups
        • Creating LDAP connections
        • Creating LDAP connection to a secured LDAP server
        • Specifying LDAP connection attributes
        • Importing users and user groups from LDAP server
      • Single sign-on users onboarding
        • SAML SSO onboarding
          • Onboarding SAML users
          • Configuring SAML users onboarding configurations
        • User onboarding using social media accounts
          • Onboarding users by using social media credentials
      • User preferences
        • Modifying user details
        • Changing your password
        • Viewing communities
        • Configuring notification preference
        • Scheduling usage reports
      • Data anonymization
        • Enabling or disabling automatic anonymization from UI
        • Anonymizing deleted user data by using REST API
      • Configuring consumer visibility
    • Managing providers
      • Creating providers
      • Mapping API or Callback URL to providers
      • Third-party API Gateway configuration
        • Integrating third-party gateways with Developer Portal
        • Publishing APIs from third-party gateways to Developer Portal
        • Creating and attaching webhooks
        • Requesting applications for third-party Gateway APIs
        • Publishing API analytics to Developer Portal
      • API partner isolation
        • Onboarding API partners
        • Assigning asset ownership
    • Managing communities
      • Creating communities
      • Mapping users, groups, or APIs to communities
      • Configuring visibility of users based on communities
    • Managing AI assets
    • Managing APIs
      • Creating APIs
      • Editing an API
      • Enriching an API
      • Creating new versions of API
      • Viewing code snippets of REST APIs
      • Downloading client Software Development Kit (SDK) for REST API resources
      • Configuring rate limit for APIs
      • Trying APIs
        • Trying REST APIs
        • Trying SOAP APIs
        • Trying OData APIs
        • Authorization fields
    • Managing applications
      • Configuring application or subscription onboarding strategy
      • Creating applications
        • Creating applications from Manage applications screen
        • Creating applications from API details page
        • Creating applications from Try API page
        • Approving application or package subscription requests
    • Managing custom assets
      • Configuring asset types
        • Property types
      • Adding custom assets to publish to webMethods Developer Portal
      • Adding custom asset gallery to UI
    • Managing lifecycle of APIs and packages
      • Lifecycle feature considerations
      • Customizing API lifecycle states
        • Customizing API lifecycle states - sample
      • Enabling lifecycle feature for APIs and packages
      • Modifying state of APIs
        • Changing the state of an API to expose it to consumers
        • Changing the state of a Live API
        • Changing an API's state to retire it from usage
      • Modifying the state of API products
        • Changing lifecycle state of packages
        • Changing lifecycle state of live packages
        • Change state of packages
    • Managing API programs
      • Hackathons
        • Creating hackathons
        • Inviting participants for API programs
        • Assigning owners for API programs
        • Registering for hackathons
        • Adding team members for hackathons
        • Adding hackathon projects
      • Beta programs
        • Creating beta programs
        • Registering for beta programs
        • Adding tickets for beta programs
  • Analyzing
    • Viewing user analytics dashboard
    • Viewing API economy insights dashboard
    • Viewing API economy trends dashboard
    • Viewing Programs dashboard
    • Viewing API usage analytics dashboard
    • Viewing applications usage dashboard
  • Troubleshooting
    • Troubleshooting APIs published from IBM webMethods API Gateway – Error message appears when you test APIs
  • Reference
    • webMethods Developer Portal REST APIs
      • Analytics
      • APIs
      • Applications
      • Approvals
      • Data backup and restore
      • Collaboration
      • Communities
      • Configurations
      • Custom assets
      • Events
      • Developer Portal Health check
      • Notifications
      • OAuth tokens
      • Packages
      • Payment gateway
      • Programs
      • Plans
      • Providers
      • Search
      • Teams
      • Topics
      • User requests
      • Users
      • Webhooks
  • Glossary
• Reference
  • The API Connect REST APIs
    • Example: Using the platform REST APIs to publish a product containing a SOAP API
      • Example Product file: globalweatherproduct_1.0.0.yaml
      • Example API definition: globalweather_1.0.0.yaml
      • Example WSDL file: globalweather.wsdl
  • API Connect TLS certificates
    • TLS certificates organized by usage
  • Troubleshooting API Connect
    • Unable to access Management UIs
    • Unable to access the portal sites
    • Login failure on Management UIs
    • Login failure on Portal sites
    • Management operations not reflected on Gateway or Portal
    • UI error after management database key rotation in Cloud Manager
  • Externally linked support topics