SSCL05_12.1.x - Documentation Index

Table of Contents

• Welcome
• API Connect V12 Reserved overview
  • What's new in API Connect V12 Reserved
  • Known limitations
  • Understanding API Connect
    • API Connect overview
    • Who does what in API Connect?
      • API Connect user roles
    • Packaging strategy and terminology in API Connect
      • Understanding rate limits for APIs and Plans
    • Developing and publishing APIs with API Connect
    • API Connect components
      • Gateway types
      • How to choose the right gateway service
    • API Connect glossary
    • Essential reading
  • Getting help from IBM support
  • Upgrades and maintenance
  • Accessibility features for IBM API Connect
  • Legal information
    • Notices
    • Terms and conditions for information centers
  • IBM API Connect Considerations for GDPR Readiness
• Administering API Connect V12 Reserved
  • Adding self-managed gateways in V12 Reserved
    • Downloading and installing a gateway
    • Setting up certificates for a self-managed gateway
    • Setting up the service authorization for IBM Cloud Secrets Manager
    • Configuring DataPower API Gateway
    • Configuring DataPower Gateway (v5 compatible)
    • Registering a gateway with V12 Reserved
  • Upgrading self-managed gateways in V12 Reserved
  • Migrating certificates to IBM Cloud Secrets Manager
  • Registering an event gateway service
  • Generate an image pull secret for Kubernetes or OpenShift
• Creating, deploying, and publishing APIs using API Agent
  • API Agent overview
  • API Agent user roles
  • Configuring
    • Watsonx.ai settings
    • API Agent settings
    • API Agent sources
      • API Connect catalogs and drafts
      • Application sources
      • Documentation files
    • Configuring MCP tools
    • 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 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
    • 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 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
      • Viewing commands in API Manager CLI
      • Building projects
      • Deploying projects
      • Testing projects
      • Getting help
• 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
    • Setting up the toolkit for V12 Reserved
    • Working offline in API Designer
    • Using the developer toolkit command-line tool
      • Overview of the command-line tool
      • 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)
      • 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
      • 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-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
    • Managing external secrets for DataPower Nano Gateway
    • Nano Gateway telemetry fields reference
  • Reference
    • API Connect context variables
    • OAuth context variables
    • Error cases supported by assembly catches
  • FAQs for designing and developing APIs
  • FAQs for gateways
• Managing your APIs
  • API management checklist
  • Using Engagement to automate notification tasks
    • Creating a notification task
    • Create scheduled reports
    • Engagement datasource
      • API events
      • Audit events
      • 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
    • Configuring Product visibility at a Catalog or Space level
    • Managing Catalog membership
    • Importing a user-defined policy into a Catalog
    • How to choose the right portal option
    • Importing an OpenAPI extension into a Catalog
    • Integrating with Postman
      • Configuring Postman settings at the provider organization level
      • Enabling Postman integration for a catalog
      • Managing Postman collections through the product lifecycle
  • Using Governance enforcement for validation
    • Configuring rulesets and enforcement type
    • Enabling governance enforcement to validate APIs and Products before publishing to a Catalog
  • 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
  • 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
    • Creating a IBM Cloud 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 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
    • 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
      • 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
    • 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
  • Reviewing processing status and downloading gateway logs
  • Reference
    • Troubleshooting your billing configuration
• Socializing your APIs using CMS Portal
  • Using the CMS Portal
    • Accessing the CMS Portal with IBM ID
    • 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
      • 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
    • Getting Started
    • 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 or preventing access from search engines
        • Toggling the site in and out of maintenance mode
      • 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
        • 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
  • 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 consumer-org commands
      • Using the content commands
      • Using the custom-module commands
      • Using the custom-theme commands
      • Using the custom-translation commands
      • Using the drupal-config commands
      • Using the drupal-state commands
      • Using the entity commands
      • Using the export-entity commands
      • Using the forums commands
      • Using the maintenance commands
      • Using the memcache commands
      • Using the modules commands
      • Using the product commands
      • Using the queue commands
      • Using the role commands
      • Using the security command
      • Using the site commands
      • Using the site-config 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
• Monitoring your API usage by using Analytics
  • Key concepts of API Connect analytics
  • API event record field reference
  • Summary API event record field reference
  • Offloading analytics data
    • Offloading analytics data to Kafka
    • Offloading analytics data to an HTTP endpoint
  • Customize your analytics data
    • Activity log policy
    • Customizing data with a gateway script or set-variable operation
  • Accessing analytics in the DataPower Interact Gateway UI
    • API Connect UIs
      • Accessing analytics in the API Manager UI
      • Accessing analytics in the Consumer catalog
      • Accessing analytics in the Developer Portal
    • AI insights and analysis for analytics
    • Export your 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
• 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
        • Retrieving transaction and event data using the APIC Analytics REST API
      • 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
    • Connecting Runtimes
      • Connecting API connect runtimes
        • Deployment considerations for connecting API Connect runtimes
  • Administering
    • User Management
      • Manage Users
        • Assigning groups to a user
      • User Profile
        • Modifying Profile Settings
        • Generating API Keys
  • Managing runtimes
    • Runtimes overview
  • Managing data planes
    • Data planes overview
  • Managing APIs
  • Managing MCP servers
  • Managing LLM Provider APIs
  • Managing administration 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
    • Monitoring performance of MCP servers
      • Metrics of MCP Servers
    • 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 LLM provider 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
    • 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