RHUI 5 Technology Preview Release Notes

Updated

Red Hat Update Infrastructure (RHUI) 5.3 Technology Preview: REST API

Released as RHSA-2026:58981 on August 24, 2026.

Technology Preview Notice: The RHUI 5.3 REST API is released as a Technology Preview. While we encourage testing and feedback, please be advised that this feature is not supported for production use and is subject to change based on user feedback and technical requirements.

This Technology Preview (TP) introduces a REST (Representational State Transfer) API (Application Programming Interface) for RHUI. In addition, this TP adds support for Kubernetes Secrets of type kubernetes.io/tls. The preview is delivered via specific container images identified by a unique suffix.

The REST API is disabled by default. Instructions on how to enable it are outlined below.

The kubernetes.io/tls Kubernetes Secret can be specified using a new argument on the rhui-manager cds k8s command line, --ssl_cert_secret_name. It is also a required parameter for the corresponding API call (to be specified as ssl_cert_secret_name in the POST request body, see below). For more information, see Content from kubernetes.io is not included.Kubernetes documentation.

Available Images

The following images are provided for this Technology Preview:

  • Installer: rhui5/installer-tp-rhel9
  • RHUA: rhui5/rhua-tp-rhel9
  • CDS: rhui5/cds-tp-rhel9
  • CDS (Kubernetes): rhui5/cds-kubernetes-tp-rhel9

Installation Procedure

The installation workflow remains consistent with standard RHUI 5 procedures. To deploy the Technology Preview, execute the installer using the TP image names. Providing these specific image names will override the default production image versions.

Prerequisites

Before proceeding, ensure you have reviewed the RHUI 5 Installation and Management Guide. You must be authenticated to the Red Hat Container Registry (registry.redhat.io) to pull the required images.

Deployment Command

Prepare an answers file to instruct the installer to enable the REST API. This is a YAML file that controls selected installation parameters that are not available as RHUI installer arguments. If you do not normally install or update RHUI with an existing answers file, create a new file with the following contents:

rhua:
  restapi_support_enabled: True

If you already use an answers file, be sure to add restapi_support_enabled: True to the rhua section in this file.

Modify your standard podman run installer command to include the TP images as shown below:

$ podman run ... \
  -v /<PATH>/answers.yaml:/answers.yaml:Z \
  registry.redhat.io/rhui5/installer-tp-rhel9 \
  rhui-installer ... --rhua-container-image rhui5/rhua-tp-rhel9 ...

All other arguments remain identical to a standard production deployment.

Modifying API Configuration

Once the RHUA is successfully deployed, you can set several additional options for the API. To do so, edit the /etc/rhui/rhui-tools.conf file in the RHUA container. Locate the [api] section. The following options are supported in addition to restapi_support_enabled, with the following default values (as predefined in /etc/rhui-static/rhui-tools-static.conf):

host: 0.0.0.0
port: 8080
workers: 4
session_length: 120
cookie_secure: False
secret_file: /etc/sysconfig/rhui-api.secret
gunicorn_timeout: 90

If you modify any of these options, restart the RHUI services or the RHUA container for the changes to take effect.

REST API Usage

Access the REST API at https://<RHUA HOSTNAME>/rhui/api/v1/<PATH>[?<QUERY PARAMETERS>]. Make sure port 443 on the RHUA host is accessible from the system that should have access to the API. To communicate with the RHUA securely, make sure your client uses the CA certificate that is configured for the RHUA web server, which is saved in /var/lib/rhui/pki/certs/ca.crt on the RHUA host (or in general, in the file inside the RHUA container which is configured in the rhui_ca_crtoption in the [security] section in /etc/rhui-static/rhui-tools-static.conf or overridden in /etc/rhui/rhui-tools.conf).

To use the REST API, you must supply either the RHUI administrator credentials (as HTTP Basic authentication) or a valid cookie. You might, however, use the credentials as data for the /login API call (see below) to obtain a cookie and then use the cookie in subsequent API calls (until the cookie expires).

The application/json Content Type is required for all POST requests.

This is an example of an API call with the curl command that uses the credentials to obtain a cookie and save it to a local file:

$ curl --cacert ca.crt -c cookie.jar -H 'Content-Type: application/json' -d '{"username": "admin", "password": "<PASSWORD>"}' https://<RHUA HOSTNAME>/rhui/api/v1/login

This is an example of an API call using the cookie obtained in the previous step:

$ curl --cacert ca.crt -b cookie.jar https://<RHUA HOSTNAME>/rhui/api/v1/repo/list

This is an example of an API call using HTTP Basic authentication:

$ curl -v --cacert ca.crt -u admin https://<RHUA HOST>/rhui/api/v1/tasks/running

Note: In this case, curl prompts for the password.

The available API calls are described below. In addition, if <RHUA HOSTNAME>:443 is accessible from your workstation, you can view an enriched version of the API documentation at https://<RHUA HOSTNAME>/rhui/api/docs/.

Caveats

  1. Before you can use the API to add repositories or check for unused products, the entitlement mappings cache must be created, which further depends on the existence of the RHUI entitlement certificate in the RHUA container. If you have SSH access to the RHUA, you can speed this up by following the instructions from Managing Repositories. Otherwise, wait until the relevant systemd timers run, which can take up to 7 hours in total. The API responds with the following error until the cache has been created:

    {"op": "repo_add", "type": "error", "error": "internal_error", "message": "The entitlement mappings cache doesn't exist."}

  2. Note that the cookie is only valid for 120 seconds by default. Be sure to refresh it regularly, or set a longer session length.

Known Issues

  1. If you disable the API after it was enabled (by reinstalling RHUI with restapi_support_enabled: False), the API will not be available anymore, but some of the configuration will remain. Consequently, attempts to use the API will be handled as HTTP 502 errors rather than HTTP 404 errors.
  2. The /cds/k8s API call can occasionally take too long to complete successfully. Please try again.
  3. The /repo/list API call, when run with sync_details=True, can time out if it takes too long to process (more than 1 minute).

Logging and Troubleshooting

The REST API uses the following log files in the /var/log/rhui/ directory in the RHUA container, which is also available as /var/lib/rhui/log/ on the host system:

  • rhui-rest-api.log - output from the underlying RHUI libraries as they are used by the API calls
  • rhui-rest-api-access.log - HTTP traffic
  • rhui-rest-api-error.log - gunicorn start/stop activities

Note: You can find additional log entries in the usual nginx log files, /var/log/nginx/access.log and /var/log/nginx/error.log.

To check if the REST API has been correctly bootstrapped, run:

[root@rhua ~]# rhua systemctl status rhui-api-init

To check if the REST API service is active, run:

[root@rhua ~]# rhua systemctl status rhui-api

RHUI REST API

Version 0.1.0

REST API layer for frequently used RHUI operations under /rhui/api/v1/. Protected routes accept either HTTP Basic credentials (forwarded to Pulp) or a signed rhuiSessionId cookie from POST /rhui/api/v1/login (SESSION_LENGTH must be configured on the API host; signing uses [api] secret_file in rhui-tools.conf by default).

Base path prefix: /rhui/api/v1/

repos

RHUI repository operations under /repo/

GET /rhui/api/v1/repo/info/

Summary: Get repository details by id

Authentication: HTTP Basic auth or cookie rhuiSessionId

Parameters:

  • path repo_id (RepoIdValue, required) — RHUI repository identifier
  • query sync_details (boolean) — When true, include sync scheduling and last-sync fields (sync_due, next_sync_date, last_sync_*). Defaults to false; those fields are omitted unless explicitly requested.

Output:

  • 200: Repository details — application/json (Repository)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 404: Requested resource not found — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
GET /rhui/api/v1/repo/list

Summary: List all RHUI repositories

Returns all RHUI-managed repositories (RPM/yum and container).

Authentication: HTTP Basic auth or cookie rhuiSessionId

Parameters:

  • query sync_details (boolean) — When true, include sync scheduling and last-sync fields (sync_due, next_sync_date, last_sync_*). Defaults to false; those fields are omitted unless explicitly requested.

Output:

  • 200: All repositories — application/json (RepositoryListResponse)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
GET /rhui/api/v1/repo/unused

Summary: List entitled Red Hat candidate repositories not yet created in RHUI

Authentication: HTTP Basic auth or cookie rhuiSessionId

Output:

  • 200: Unused candidate repositories — application/json (UnusedRedHatRepositoriesResponse)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
POST /rhui/api/v1/repo/add

Summary: Add Red Hat repositories by id or product

Registers undeployed Red Hat repositories. Supply either repo_ids (explicit repository identifiers) or product_names (all undeployed repos in each product). Exactly one of those arrays must be provided and must be non-empty. Unknown product names are reported in error. Optional sync_now schedules a Pulp sync task immediately after each repository is successfully created. The response is always application/x-ndjson (one JSON object per line per repository processed).

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — RepositoryCreateRequest
      • Exactly one of repo_ids or product_names must be supplied (non-empty array).
      • One of:
        • RepositoryCreateByRepoIdsRequest:
          • repo_ids (array of string, required) — RHUI repository identifiers to add
          • sync_now (boolean) — When true, schedule a sync immediately after each repository is successfully created
        • RepositoryCreateByProductNamesRequest:
          • product_names (array of string, required) — Entitlement product names; all undeployed repositories in each product are added
          • sync_now (boolean) — When true, schedule a sync immediately after each repository is successfully created

Output:

  • 200: Per-repository add results streamed as NDJSON — application/x-ndjson (RepoOpStreamEvent)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
POST /rhui/api/v1/repo/create_custom

Summary: Create a custom RPM repository

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — RepoCreateCustomRequest
      • repo_id (string, required) — Repository id (alphanumerics, underscore, hyphen only)
      • display_name (string) — Human-readable name; defaults to repo_id
      • path (string) — Relative path segment; defaults to repo_id
      • protected (boolean) — If true, repo is placed under the protected URL prefix
      • gpg_public_keys (array of string) — Absolute paths to GPG public key files
      • redhat_content (boolean) — If true, associate Red Hat release RPM GPG key metadata

Output:

  • 201: Repository created — application/json (RepoCreateCustomResponse)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 409: Resource already exists or cannot be created in current state — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
POST /rhui/api/v1/repo/delete

Summary: Delete repositories by id

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — RepoDeleteRequest
      • repo_ids (array of string, required)

Output:

  • 200: Repository delete scheduling events streamed as NDJSON — application/x-ndjson (RepoOpStreamEvent)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
POST /rhui/api/v1/repo/sync

Summary: Trigger repository syncs

Schedule repository syncs. Supply either all (must be true) to sync all Red Hat repos, or repo_ids (non-empty) to sync specific repositories. Exactly one of those selectors is required. With cron true, applies the same due-date filtering as rhui-tools sync when run from cron. The response is always newline-delimited JSON (application/x-ndjson): one event per line while scheduling.

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — RepoSyncRequest
      • Exactly one of all or repo_ids must be supplied. cron is optional and defaults to false.
      • One of:
        • RepoSyncByAllRequest:
          • cron (boolean) — When true, skip repos whose scheduled sync is not yet due (cron-style)
          • all (boolean, required) — Must be true; sync all Red Hat repositories
        • RepoSyncByRepoIdsRequest:
          • cron (boolean) — When true, skip repos whose scheduled sync is not yet due (cron-style)
          • repo_ids (array of string, required) — Repositories to sync

Output:

  • 200: Sync scheduling events streamed as NDJSON — application/x-ndjson (RepoOpStreamEvent)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 502: Upstream Pulp service error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)

packages

RPM package listing under /packages/

GET /rhui/api/v1/packages/list/

Summary: List RPM packages in a repository

Streams packages from the latest repository version of the named RPM (yum) repository only. The response is always application/x-ndjson (one JSON object per line). Results are sorted by full RPM filename (name-version-release.arch.rpm) before streaming. Each package line includes mandatory RPM metadata under package; optional field query parameters add further keys from the Pulp RPM package JSON. Optional filters: name, namepart, version, and release (see parameter descriptions).

Authentication: HTTP Basic auth or cookie rhuiSessionId

Parameters:

  • path repo_id (RepoIdValue, required) — RHUI repository identifier
  • query field (PackageListFieldValue) — Optional. Repeat to include extra Pulp RPM package attributes. Each value must be one of the enum entries (mandatory response keys are ignored if listed). Omit this parameter entirely when no extra fields are needed.
  • query name (PackageListNameFilter) — Exact match on the RPM package name (Pulp name field, not the filename).
  • query namepart (PackageListNamePartFilter) — Partial match on the RPM package name (Pulp name field, not the filename).
  • query version (PackageListVersionFilter) — Exact match on the RPM package version field.
  • query release (PackageListReleaseFilter) — Partial match on the RPM package release field.

Output:

  • 200: Package list events streamed as NDJSON (sorted by filename) — application/x-ndjson (PackageListStreamEvent)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 404: Requested resource not found — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
POST /rhui/api/v1/packages/remove

Summary: Remove RPM packages from a custom repository

Removes matching RPM packages from a custom RPM repository, the same way as rhui-manager packages remove. repo_id must identify an existing custom RPM repository. package is the package name to remove. Optional vr limits removal to a specific version-release (version-release). Returns the disassociate task_href and the list of RPM filenames queued for removal. Unlike the CLI, this endpoint does not prompt for confirmation.

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — PackageRemoveRequest
      • repo_id (string, required) — Custom RPM repository id to remove packages from
      • package (string, required) — Package name to remove
      • vr (string) — Optional version-release filter (version-release). When set, only that version-release of the package is removed.

Output:

  • 202: Package removal task queued — application/json (PackageRemoveResponse)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 404: Requested resource not found — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
POST /rhui/api/v1/packages/upload

Summary: Upload RPM packages to a custom repository

Uploads a package file or directory of RPMs into a custom RPM repository, the same way as rhui-manager packages upload. Copies packages to a temporary directory, generates repository metadata, and queues an additive Pulp sync. Returns the sync task_href and the list of RPM filenames queued for upload. repo_id must identify an existing custom RPM repository. packages must be an absolute path on the RHUA to a .rpm file or a directory containing .rpm files.

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — PackageUploadRequest
      • repo_id (string, required) — Custom RPM repository id that will receive the packages
      • packages (string, required) — Absolute path on the RHUA to a .rpm file or a directory containing .rpm files (must exist and be readable)

Output:

  • 202: Package upload sync task queued — application/json (PackageUploadResponse)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 404: Requested resource not found — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)

cds

Content Delivery Server operations under /cds/

POST /rhui/api/v1/cds/k8s

Summary: Generate Kubernetes YAML for a CDS deployment

Generates Kubernetes manifests for a CDS deployment, similar to rhui-manager cds k8s. ssl_cert_secret_name is required and names an existing kubernetes.io/tls Secret; local SSL certificate generation and user-supplied SSL files are not supported on this endpoint. File injection (--inject) is not yet available. Returns a single JSON object whose manifest field contains the generated Kubernetes YAML. The manifest is not written to the RHUA filesystem.

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — CdsK8sRequest
      • ssl_cert_secret_name (string, required) — Name of an existing Kubernetes Secret of type kubernetes.io/tls that holds the CDS TLS certificate and key

Output:

  • 200: Generated CDS Kubernetes manifest — application/json (CdsK8sResponse)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)

tasks

Pulp task status under /tasks/

GET /rhui/api/v1/tasks/running

Summary: List running Pulp tasks

Returns all Pulp tasks in the running state. Each item includes the task name, a derived task type, progress reports, and repository_ids resolved from reserved_resources_record (and distribution tasks recorded in repo notes) when the task is coupled to RHUI repositories.

Authentication: HTTP Basic auth or cookie rhuiSessionId

Output:

  • 200: Running Pulp tasks — application/json (RunningTasksResponse)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
GET /rhui/api/v1/tasks/waiting

Summary: List waiting Pulp tasks

Returns all Pulp tasks in the waiting state, ordered by pulp_created ascending (oldest queued first). Each item includes the task name, a derived task type, and repository_ids resolved from reserved_resources_record (and distribution tasks recorded in repo notes) when the task is coupled to RHUI repositories. Progress reports are not included (tasks have not started yet).

Authentication: HTTP Basic auth or cookie rhuiSessionId

Output:

  • 200: Waiting Pulp tasks — application/json (WaitingTasksResponse)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)

client

Client certificate helpers under /client/

GET /rhui/api/v1/client/labels

Summary: List repository labels for client certificate creation

Returns the same repository labels as rhui-manager client labels: entitlement labels from valid (non-expired) Red Hat content certificates on the RHUA, sorted by label. These labels are used with client entitlement certificate creation and may differ from deployed repository ids.

Authentication: HTTP Basic auth or cookie rhuiSessionId

Output:

  • 200: Repository labels available for client certificates — application/json (ClientLabelsResponse)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
POST /rhui/api/v1/client/cert

Summary: Generate a client entitlement certificate

Creates a client entitlement certificate the same way as rhui-manager client cert. Required fields map to the CLI options --repo_label, --name, --days, and --dir. Label resolution matches the CLI (Red Hat entitlement prefix match and custom-repo_id labels). Unknown labels yield HTTP 400.

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — ClientCertRequest
      • repo_labels (array of string, required) — Repository/entitlement labels to include (CLI --repo_label). Matching follows the CLI: Red Hat entitlement label prefix, or custom-repo_id for custom entitlements.
      • name (string, required) — Certificate base name (CLI --name); used for name.crt and name.key
      • days (integer, required) — Number of days the certificate will be valid (CLI --days)
      • dir (string, required) — Absolute directory on the RHUA where the certificate will be stored (CLI --dir). Must start with /, already exist, and be writable.

Output:

  • 201: Client entitlement certificate created — application/json (ClientCertResponse)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
POST /rhui/api/v1/client/rpm

Summary: Generate a client configuration RPM

Creates a client configuration RPM. When entitlement_certfile and entitlement_cert_keyfile are both supplied, those files are used and certificate generation is skipped (repo_labels must not be set). Otherwise behaves like rhui-manager client rpm --cert: generates an entitlement certificate from repo_labels (when supplied) and builds the RPM under dir. Without a supplied certificate pair, at least one of repo_labels or unprotected_repos must be a non-empty array. Unknown or invalid labels/repos yield HTTP 400.

Authentication: HTTP Basic auth or cookie rhuiSessionId

Input:

  • Request body (required):
    • application/json — ClientRpmRequest
      • dir (string, required) — Absolute path on the RHUA where the client RPM will be generated. Must start with /, already exist as a directory, and be writable.
      • rpm_name (string, required) — RPM package name (RPM naming rules)
      • repo_labels (array of string) — Content certificate entitlement labels to include in a newly generated cert. Must not be set when entitlement_certfile / entitlement_cert_keyfile are supplied.
      • unprotected_repos (array of string) — Unprotected custom repository ids to include in the client config
      • entitlement_certfile (string) — Absolute path to an existing entitlement certificate (.crt). Must be paired with entitlement_cert_keyfile; both files must be readable.
      • entitlement_cert_keyfile (string) — Absolute path to the private key for entitlement_certfile. Must be paired with entitlement_certfile; both files must be readable.
      • rpm_release (string) — Release of the generated RPM package
      • rpm_version (string) — Version of the generated RPM package
      • days (integer) — Number of days the generated entitlement certificate will be valid (ignored when entitlement_certfile / entitlement_cert_keyfile are supplied)
      • proxy (string) — Optional proxy URL/string for yum repo files
      • ca_cert (string) — Full path to the CDS SSL CA certificate (defaults to ssl_ca_crt in rhui-tools.conf)
      • omit_repo_sslcacert (boolean) — When true, omit sslcacert from rh-cloud.repo and omit ca.crt from the RPM (use when CDS TLS uses a publicly trusted certificate)

Output:

  • 201: Client configuration RPM created — application/json (ClientRpmResponse)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)

session

Session authentication against Pulp

POST /rhui/api/v1/login

Summary: Establish a Pulp session cookie for the API

Authenticates against Pulp using the Django login form and returns a signed rhuiSessionId cookie (Pulp sessionid, absolute expiry, HMAC) for subsequent calls. Using cookie authentication is the preferred authentication method over the basic authentication which creates a new Pulp session, which can be a significant overhead when a lot af API calls are fired in short time. Further, cookie expiry time is configured on the RHUI level and is independent of the Pulp login session length (which is 2 weeks by default).

Authentication: None (public endpoint)

Input:

  • Request body (required):
    • application/json — LoginRequest
      • username (string, required)
      • password (string, required)

Output:

  • 200: Login succeeded; Set-Cookie rhuiSessionId is issued — application/json (LoginSuccess)
  • 400: Invalid request — application/json (Error)
  • 401: Authentication required or invalid credentials — application/json (Error)
  • 500: Unexpected internal error — application/json (Error)
  • 503: Required session signing configuration is missing or invalid — application/json (Error)
Product(s)
Category
Article Type