# Create auth credential

`POST /v1/authcredentials`

Available as MCP tool `create-auth-cred` (Write).

Credential endpoints allow you to manage custom authentication strategies for your organization's destinations. Destinations are the endpoints in your system that receive data from Redox. 

You may choose custom authentication for your destinations if you want more secure authentication credentials for any data coming into your system. 

With this set of Platform API endpoints, you can:

- retrieve a list of existing auth credentials for an environment;
- retrieve one auth credential by its ID;
- retrieve a list of supported auth strategies;
- create a new auth credential;
- update an existing auth credential; or
- delete an existing auth credential.

### Create auth credential

Create a new auth credential that you can use to verify your destination(s).

The response contains details of the new auth credential but doesn't include any secret values. Instead, secrets are replaced with boolean fields that indicate whether a secret value exists with a `true` or `false` value. The field name has the format of `has<PropertyName>`.

## Request body

### One of: OAuth 2.0 Two-Legged with secrets

This is an authentication strategy type that uses an OAuth client, authorization server, and system server. The OAuth client requests an access token from the authorization server. The returned access token can be used to access the system server.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `(Client credentials).grantType` | string | Yes | Value: client_credentials |
| `(Client credentials).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `(Client credentials).grantTypeName` | string | No | Enter the parameter name used to specify the grant type in the access token request body (e.g., grant_type or grantType). |
| `(Client credentials).clientIdName` | string | No | Enter the key name for sending the client ID in a token request (e.g., client_id or clientId). |
| `(Client credentials).clientSecretName` | string | No | Enter the key name for sending the client secret in a token request (e.g., client_secret or clientSecret). |
| `(Client credentials).refreshTokenName` | string | No | Specify the name used to pass a refresh token when requesting a new access token (e.g., refresh_token or refreshToken). |
| `(Client credentials).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(Client credentials).clientSecret` | string | No | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `(Client credentials).accessTokenName` | string | No | Specify the name used to pass the access token in the API request (e.g., access_token or accessToken). It’s typically included in the request header. |
| `(Client credentials).expiresFieldName` | string | No | Define the name of the field that specifies an access token expires (e.g., expires or expires_in). This is used to track when the access token will no longer be valid to make API requests. |
| `(Client credentials).refreshGrantType` | string | No | Specify the grant type used for refreshing an expired token (e.g., refresh_token or refresh). |
| `(Client credentials).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(Client credentials).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `(Client credentials).contentType` | string | No | Indicate the format of the request body (e.g., application/x-www-form-urlencoded or application/json). |
| `(Client credentials).noBasic` | string | No | Set to true to suppress sending the auth object in OAuth requests |
| `(Client credentials).resource` | string | No | Enter the URI that represents the resource the client is trying to access. In some cases, it defines the target for access token issuance. |
| `(Client credentials).customFieldName` | string | No | Define the name of the custom parameter that may be required by a specific implementation. Used by Redox for advanced configurations. |
| `(Client credentials).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `(Client credentials).defaultExpirationSeconds` | string | No | Define the default duration (in seconds) that an access token remains valid before it needs to be refreshed or reissued. |
| `(Client credentials).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `(Client credentials).basicNoForm` | boolean | No | If enabled, the client_id and client_secret will not be included in the form data, only grant_type |
| `(Client credentials).excludeRedirectUri` | boolean | No | If enabled, the `redirect_uri` parameter will be excluded in the token request. This parameter is not used by most 2-legged OAuth flows, but is included by default for legacy reasons. |
| `(Authorization code).grantType` | string | Yes | Value: authorization_code |
| `(Authorization code).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `(Authorization code).grantTypeName` | string | No | Enter the parameter name used to specify the grant type in the access token request body (e.g., grant_type or grantType). |
| `(Authorization code).clientIdName` | string | No | Enter the key name for sending the client ID in a token request (e.g., client_id or clientId). |
| `(Authorization code).clientSecretName` | string | No | Enter the key name for sending the client secret in a token request (e.g., client_secret or clientSecret). |
| `(Authorization code).refreshTokenName` | string | No | Specify the name used to pass a refresh token when requesting a new access token (e.g., refresh_token or refreshToken). |
| `(Authorization code).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(Authorization code).clientSecret` | string | No | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `(Authorization code).accessTokenName` | string | No | Specify the name used to pass the access token in the API request (e.g., access_token or accessToken). It’s typically included in the request header. |
| `(Authorization code).expiresFieldName` | string | No | Define the name of the field that specifies an access token expires (e.g., expires or expires_in). This is used to track when the access token will no longer be valid to make API requests. |
| `(Authorization code).refreshGrantType` | string | No | Specify the grant type used for refreshing an expired token (e.g., refresh_token or refresh). |
| `(Authorization code).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(Authorization code).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `(Authorization code).contentType` | string | No | Indicate the format of the request body (e.g., application/x-www-form-urlencoded or application/json). |
| `(Authorization code).noBasic` | string | No | Set to true to suppress sending the auth object in OAuth requests |
| `(Authorization code).resource` | string | No | Enter the URI that represents the resource the client is trying to access. In some cases, it defines the target for access token issuance. |
| `(Authorization code).customFieldName` | string | No | Define the name of the custom parameter that may be required by a specific implementation. Used by Redox for advanced configurations. |
| `(Authorization code).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `(Authorization code).defaultExpirationSeconds` | string | No | Define the default duration (in seconds) that an access token remains valid before it needs to be refreshed or reissued. |
| `(Authorization code).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `(Authorization code).basicNoForm` | boolean | No | If enabled, the client_id and client_secret will not be included in the form data, only grant_type |
| `(Authorization code).excludeRedirectUri` | boolean | No | If enabled, the `redirect_uri` parameter will be excluded in the token request. This parameter is not used by most 2-legged OAuth flows, but is included by default for legacy reasons. |
| `(Resource owner password credentials).grantType` | string | Yes | Value: password |
| `(Resource owner password credentials).username` | string | Yes | Enter the user’s name as defined in the Resource Owner Password Credentials Grant flow. The client submits the username and password to obtain an access token. |
| `(Resource owner password credentials).password` | string | Yes | Enter the user’s password as defined in the Resource Owner Password Credentials Grant flow. The client submits the username and password to obtain an access token. |
| `(Resource owner password credentials).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `(Resource owner password credentials).grantTypeName` | string | No | Enter the parameter name used to specify the grant type in the access token request body (e.g., grant_type or grantType). |
| `(Resource owner password credentials).clientIdName` | string | No | Enter the key name for sending the client ID in a token request (e.g., client_id or clientId). |
| `(Resource owner password credentials).clientSecretName` | string | No | Enter the key name for sending the client secret in a token request (e.g., client_secret or clientSecret). |
| `(Resource owner password credentials).refreshTokenName` | string | No | Specify the name used to pass a refresh token when requesting a new access token (e.g., refresh_token or refreshToken). |
| `(Resource owner password credentials).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(Resource owner password credentials).clientSecret` | string | No | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `(Resource owner password credentials).accessTokenName` | string | No | Specify the name used to pass the access token in the API request (e.g., access_token or accessToken). It’s typically included in the request header. |
| `(Resource owner password credentials).expiresFieldName` | string | No | Define the name of the field that specifies an access token expires (e.g., expires or expires_in). This is used to track when the access token will no longer be valid to make API requests. |
| `(Resource owner password credentials).refreshGrantType` | string | No | Specify the grant type used for refreshing an expired token (e.g., refresh_token or refresh). |
| `(Resource owner password credentials).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(Resource owner password credentials).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `(Resource owner password credentials).contentType` | string | No | Indicate the format of the request body (e.g., application/x-www-form-urlencoded or application/json). |
| `(Resource owner password credentials).noBasic` | string | No | Set to true to suppress sending the auth object in OAuth requests |
| `(Resource owner password credentials).resource` | string | No | Enter the URI that represents the resource the client is trying to access. In some cases, it defines the target for access token issuance. |
| `(Resource owner password credentials).customFieldName` | string | No | Define the name of the custom parameter that may be required by a specific implementation. Used by Redox for advanced configurations. |
| `(Resource owner password credentials).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `(Resource owner password credentials).defaultExpirationSeconds` | string | No | Define the default duration (in seconds) that an access token remains valid before it needs to be refreshed or reissued. |
| `(Resource owner password credentials).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `(Resource owner password credentials).basicNoForm` | boolean | No | If enabled, the client_id and client_secret will not be included in the form data, only grant_type |
| `(Resource owner password credentials).excludeRedirectUri` | boolean | No | If enabled, the `redirect_uri` parameter will be excluded in the token request. This parameter is not used by most 2-legged OAuth flows, but is included by default for legacy reasons. |
| `(Custom grant type).grantType` | string | Yes | Value: custom |
| `(Custom grant type).customGrantType` | string | Yes | Define a non-standard grant type used for obtaining access tokens. |
| `(Custom grant type).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `(Custom grant type).grantTypeName` | string | No | Enter the parameter name used to specify the grant type in the access token request body (e.g., grant_type or grantType). |
| `(Custom grant type).clientIdName` | string | No | Enter the key name for sending the client ID in a token request (e.g., client_id or clientId). |
| `(Custom grant type).clientSecretName` | string | No | Enter the key name for sending the client secret in a token request (e.g., client_secret or clientSecret). |
| `(Custom grant type).refreshTokenName` | string | No | Specify the name used to pass a refresh token when requesting a new access token (e.g., refresh_token or refreshToken). |
| `(Custom grant type).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(Custom grant type).clientSecret` | string | No | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `(Custom grant type).accessTokenName` | string | No | Specify the name used to pass the access token in the API request (e.g., access_token or accessToken). It’s typically included in the request header. |
| `(Custom grant type).expiresFieldName` | string | No | Define the name of the field that specifies an access token expires (e.g., expires or expires_in). This is used to track when the access token will no longer be valid to make API requests. |
| `(Custom grant type).refreshGrantType` | string | No | Specify the grant type used for refreshing an expired token (e.g., refresh_token or refresh). |
| `(Custom grant type).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(Custom grant type).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `(Custom grant type).contentType` | string | No | Indicate the format of the request body (e.g., application/x-www-form-urlencoded or application/json). |
| `(Custom grant type).noBasic` | string | No | Set to true to suppress sending the auth object in OAuth requests |
| `(Custom grant type).resource` | string | No | Enter the URI that represents the resource the client is trying to access. In some cases, it defines the target for access token issuance. |
| `(Custom grant type).customFieldName` | string | No | Define the name of the custom parameter that may be required by a specific implementation. Used by Redox for advanced configurations. |
| `(Custom grant type).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `(Custom grant type).defaultExpirationSeconds` | string | No | Define the default duration (in seconds) that an access token remains valid before it needs to be refreshed or reissued. |
| `(Custom grant type).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `(Custom grant type).basicNoForm` | boolean | No | If enabled, the client_id and client_secret will not be included in the form data, only grant_type |
| `(Custom grant type).excludeRedirectUri` | boolean | No | If enabled, the `redirect_uri` parameter will be excluded in the token request. This parameter is not used by most 2-legged OAuth flows, but is included by default for legacy reasons. |

### One of: JWT Bearer

This is an authentication strategy type that uses an encoded token to verify and grant an access token from an authorization server. The returned access token can be used to access the system server.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `(HS256).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: HS256 |
| `(HS256).clientSecret` | string | Yes | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `(HS256).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(HS256).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(HS256).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(HS256).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(HS256).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(HS256).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(HS256).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(HS256).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(HS384).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: HS384 |
| `(HS384).clientSecret` | string | Yes | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `(HS384).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(HS384).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(HS384).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(HS384).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(HS384).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(HS384).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(HS384).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(HS384).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(HS512).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: HS512 |
| `(HS512).clientSecret` | string | Yes | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `(HS512).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(HS512).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(HS512).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(HS512).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(HS512).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(HS512).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(HS512).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(HS512).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(RS256).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: RS256 |
| `(RS256).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(RS256).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(RS256).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(RS256).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(RS256).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(RS256).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(RS256).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(RS256).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(RS256).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(RS256).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(RS256).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(RS384).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: RS384 |
| `(RS384).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(RS384).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(RS384).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(RS384).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(RS384).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(RS384).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(RS384).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(RS384).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(RS384).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(RS384).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(RS384).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(RS512).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: RS512 |
| `(RS512).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(RS512).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(RS512).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(RS512).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(RS512).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(RS512).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(RS512).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(RS512).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(RS512).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(RS512).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(RS512).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(PS256).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: PS256 |
| `(PS256).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(PS256).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(PS256).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(PS256).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(PS256).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(PS256).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(PS256).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(PS256).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(PS256).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(PS256).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(PS256).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(PS384).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: PS384 |
| `(PS384).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(PS384).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(PS384).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(PS384).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(PS384).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(PS384).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(PS384).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(PS384).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(PS384).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(PS384).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(PS384).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(PS512).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: PS512 |
| `(PS512).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(PS512).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(PS512).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(PS512).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(PS512).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(PS512).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(PS512).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(PS512).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(PS512).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(PS512).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(PS512).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(ES256).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: ES256 |
| `(ES256).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(ES256).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(ES256).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(ES256).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(ES256).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(ES256).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(ES256).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(ES256).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(ES256).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(ES256).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(ES256).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(ES384).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: ES384 |
| `(ES384).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(ES384).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(ES384).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(ES384).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(ES384).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(ES384).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(ES384).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(ES384).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(ES384).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(ES384).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(ES384).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `(ES512).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: ES512 |
| `(ES512).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `(ES512).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `(ES512).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `(ES512).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `(ES512).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `(ES512).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `(ES512).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `(ES512).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `(ES512).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `(ES512).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `(ES512).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |

### One of: SMART Backend with secrets

This is an authentication strategy type that relies on SMART’s Backend Services authorization mechanism to retrieve access tokens. Specifically, Redox uses the `client-confidential-asymmetric` authentication mechanism as the client.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `organization` | number | Yes | Contains your unique Redox organization identifier. |
| `name` | string | Yes | Displays the name of the auth credential. |
| `environmentId` | string | Yes | Identifies the specific environment that the auth credential is used in. |
| `grantType` | string | Yes | Define the method used to obtain the access token. Depending on the auth strategy, it’s common to use client_credentials or password. Value: client_credentials |
| `privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Possible values: HS256, HS384, HS512, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384, ES512 |
| `url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `clientCert` | Option 1 or Option 2 | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `clientCert (Option 1)` | string (uuid) | No |  |
| `clientCert (Option 2)` | string | No | Value:  |
| `clientCertKey` | Option 1 or Option 2 | No | Provide a digital certificate key used to authenticate the client to the server. This key is paired with the client certificate. |
| `clientCertKey (Option 1)` | string (uuid) | No |  |
| `clientCertKey (Option 2)` | string | No | Value:  |
| `tokenHeader` | string | No | Enter a custom header name for the bearer token (e.g. X-ACCESS). If set, the bearer token will go in this header instead of the Authorization header. |
| `includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `includeJKU` | boolean | No | If enabled, JWTs generated by the strategy will include the jku header. |
| `clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `authStrategy` | string | No | Indicates the specific strategy type that this auth credential belongs to. Value: SMART_Backend |

### One of: Google Workload Identity Federation

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `organization` | number | Yes | Contains your unique Redox organization identifier. |
| `name` | string | Yes | Displays the name of the auth credential. |
| `environmentId` | string | Yes | Identifies the specific environment that the auth credential is used in. |
| `audience` | string | Yes | Indicates the system that should consume the authentication credentials. This field isn't required but is sent in the `audience` field of the authorization request when populated. |
| `delegates` | string | Yes | Designates the system that must provide the final access token in the authentication workflow. |
| `lifetime` | string | Yes | Specifies the length of time that the delegated credentials are valid, typically in number of seconds. |
| `scope` | string | Yes | Defines the scope or access granted with the authentication credentials. |
| `service_account_impersonation_url` | string | Yes | Contains the URL (provided by the external identity provider) that a system uses to impersonate the service account in order to get access. |
| `options` | string or null | No | Defines an additional set of features that the Security Token Service supports. |
| `sts_scope` | string | No | Defines the scope or access granted by the Security Token Service. |
| `token_url` | string | No | Contains the endpoint URL for the GCP Security Token Service. |
| `authStrategy` | string | No | Indicates the specific strategy type that this auth credential belongs to. Value: GoogleWIF |

### One of: AWS Signature Version 4

This is an authentication strategy type that uses the AWS Signature Version 4 algorithm to sign requests to AWS services. [Check out AWS's docs](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) for more information.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `organization` | number | Yes | Contains your unique Redox organization identifier. |
| `name` | string | Yes | Displays the name of the auth credential. |
| `environmentId` | string | Yes | Identifies the specific environment that the auth credential is used in. |
| `accessKey` | string | Yes | Provide the key used in conjunction with AWS SigV4 authentication to identify the user or system making the API request. |
| `secretKey` | string | Yes | Provide the private key used in AWS SigV4 authentication. This is paired with the access key to sign requests. |
| `serviceName` | string | Yes | Specify the AWS service name to connect to (e.g., default is healthlake). |
| `authStrategy` | string | Yes | Indicates the specific strategy type that this auth credential belongs to. Value: AwsSigV4 |
| `awsRegion` | string | No | Specify the AWS region the service is in. (e.g., default is us-east-1). |
| `sessionToken` | string | No | Provide a temporary access token used in AWS SigV4 authentication to authenticate API requests when using temporary security credentials. |

### One of: OAuth 2.0 JWT GCP

This is an authentication strategy type that uses the OAuth 2.0 JWT GCP algorithm to sign requests to Google Cloud Platform services. [Check out Google's docs](https://developers.google.com/identity/protocols/oauth2/service-account) for more information.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `organization` | number | Yes | Contains your unique Redox organization identifier. |
| `name` | string | Yes | Displays the name of the auth credential. |
| `environmentId` | string | Yes | Identifies the specific environment that the auth credential is used in. |
| `url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `keyId` | string | Yes | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Possible values: HS256, HS384, HS512, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384, ES512 |
| `authStrategy` | string | Yes | Indicates the specific strategy type that this auth credential belongs to. Value: OAuth_2.0_JWT_GCP |
| `customGrantType` | string | No | Set this to override the default `urn:ietf:params:oauth:grant-type:jwt-bearer` grant type expected by GCP |
| `clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |

## Request example

_Generated from the schema: the values are placeholders, not a real payload._

```bash
curl 'https://api.redoxengine.com/platform/v1/authcredentials' \
--request POST \
--header 'Authorization: Bearer $API_TOKEN' \
--header 'accept: application/json' \
--header 'Content-Type: application/json' \
--data '{
  "organization": 118,
  "name": "Sample Auth Credential",
  "environmentId": "a31a92e5-43b7-45df-8085-4ac5a746d105",
  "grantType": "client_credentials",
  "url": "string",
  "grantTypeName": "grant_type",
  "clientIdName": "client_id",
  "clientSecretName": "client_secret",
  "refreshTokenName": "refresh_token",
  "clientId": "string",
  "clientSecret": "zzzSecret-assigned-by-authorization-server!!",
  "accessTokenName": "string",
  "expiresFieldName": "string",
  "refreshGrantType": "string",
  "audience": "string",
  "scopes": "string",
  "contentType": "string",
  "noBasic": "string",
  "resource": "string",
  "customFieldName": "string",
  "customFieldValue": "string",
  "defaultExpirationSeconds": "string",
  "caCertificateChain": "string",
  "basicNoForm": true,
  "excludeRedirectUri": true,
  "authStrategy": "OAuth_2.0_2-legged"
}'
```

## Responses

### 200

Contains a `payload` object with the available authentication strategies.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `meta` | object | No |  |
| `meta.version` | string | No | Lists the major and minor version number for the format of the returned payload. The payload format or shape may change between minor versions, like including additional or extended fields in later versions. We include the version data in each response so that you have the option to handle the signaled differences. |
| `payload` | OAuth 2.0 Two-Legged without secrets or JWT Bearer without secrets or Google Workload Identity Federation or SMART Backend without secrets or AWS Signature Version 4 without sercrets or OAuth 2.0 JWT GCP without private keys | No |  |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).grantType` | string | Yes | Value: client_credentials |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).grantTypeName` | string | No | Enter the parameter name used to specify the grant type in the access token request body (e.g., grant_type or grantType). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).clientIdName` | string | No | Enter the key name for sending the client ID in a token request (e.g., client_id or clientId). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).clientSecretName` | string | No | Enter the key name for sending the client secret in a token request (e.g., client_secret or clientSecret). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).refreshTokenName` | string | No | Specify the name used to pass a refresh token when requesting a new access token (e.g., refresh_token or refreshToken). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).clientSecret` | string | No | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).accessTokenName` | string | No | Specify the name used to pass the access token in the API request (e.g., access_token or accessToken). It’s typically included in the request header. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).expiresFieldName` | string | No | Define the name of the field that specifies an access token expires (e.g., expires or expires_in). This is used to track when the access token will no longer be valid to make API requests. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).refreshGrantType` | string | No | Specify the grant type used for refreshing an expired token (e.g., refresh_token or refresh). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).contentType` | string | No | Indicate the format of the request body (e.g., application/x-www-form-urlencoded or application/json). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).noBasic` | string | No | Set to true to suppress sending the auth object in OAuth requests |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).resource` | string | No | Enter the URI that represents the resource the client is trying to access. In some cases, it defines the target for access token issuance. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).customFieldName` | string | No | Define the name of the custom parameter that may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).defaultExpirationSeconds` | string | No | Define the default duration (in seconds) that an access token remains valid before it needs to be refreshed or reissued. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).basicNoForm` | boolean | No | If enabled, the client_id and client_secret will not be included in the form data, only grant_type |
| `payload (OAuth 2.0 Two-Legged without secrets) (Client credentials).excludeRedirectUri` | boolean | No | If enabled, the `redirect_uri` parameter will be excluded in the token request. This parameter is not used by most 2-legged OAuth flows, but is included by default for legacy reasons. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).grantType` | string | Yes | Value: authorization_code |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).grantTypeName` | string | No | Enter the parameter name used to specify the grant type in the access token request body (e.g., grant_type or grantType). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).clientIdName` | string | No | Enter the key name for sending the client ID in a token request (e.g., client_id or clientId). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).clientSecretName` | string | No | Enter the key name for sending the client secret in a token request (e.g., client_secret or clientSecret). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).refreshTokenName` | string | No | Specify the name used to pass a refresh token when requesting a new access token (e.g., refresh_token or refreshToken). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).clientSecret` | string | No | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).accessTokenName` | string | No | Specify the name used to pass the access token in the API request (e.g., access_token or accessToken). It’s typically included in the request header. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).expiresFieldName` | string | No | Define the name of the field that specifies an access token expires (e.g., expires or expires_in). This is used to track when the access token will no longer be valid to make API requests. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).refreshGrantType` | string | No | Specify the grant type used for refreshing an expired token (e.g., refresh_token or refresh). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).contentType` | string | No | Indicate the format of the request body (e.g., application/x-www-form-urlencoded or application/json). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).noBasic` | string | No | Set to true to suppress sending the auth object in OAuth requests |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).resource` | string | No | Enter the URI that represents the resource the client is trying to access. In some cases, it defines the target for access token issuance. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).customFieldName` | string | No | Define the name of the custom parameter that may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).defaultExpirationSeconds` | string | No | Define the default duration (in seconds) that an access token remains valid before it needs to be refreshed or reissued. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).basicNoForm` | boolean | No | If enabled, the client_id and client_secret will not be included in the form data, only grant_type |
| `payload (OAuth 2.0 Two-Legged without secrets) (Authorization code).excludeRedirectUri` | boolean | No | If enabled, the `redirect_uri` parameter will be excluded in the token request. This parameter is not used by most 2-legged OAuth flows, but is included by default for legacy reasons. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).grantType` | string | Yes | Value: password |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).username` | string | Yes | Enter the user’s name as defined in the Resource Owner Password Credentials Grant flow. The client submits the username and password to obtain an access token. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).password` | string | Yes | Enter the user’s password as defined in the Resource Owner Password Credentials Grant flow. The client submits the username and password to obtain an access token. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).grantTypeName` | string | No | Enter the parameter name used to specify the grant type in the access token request body (e.g., grant_type or grantType). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).clientIdName` | string | No | Enter the key name for sending the client ID in a token request (e.g., client_id or clientId). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).clientSecretName` | string | No | Enter the key name for sending the client secret in a token request (e.g., client_secret or clientSecret). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).refreshTokenName` | string | No | Specify the name used to pass a refresh token when requesting a new access token (e.g., refresh_token or refreshToken). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).clientSecret` | string | No | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).accessTokenName` | string | No | Specify the name used to pass the access token in the API request (e.g., access_token or accessToken). It’s typically included in the request header. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).expiresFieldName` | string | No | Define the name of the field that specifies an access token expires (e.g., expires or expires_in). This is used to track when the access token will no longer be valid to make API requests. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).refreshGrantType` | string | No | Specify the grant type used for refreshing an expired token (e.g., refresh_token or refresh). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).contentType` | string | No | Indicate the format of the request body (e.g., application/x-www-form-urlencoded or application/json). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).noBasic` | string | No | Set to true to suppress sending the auth object in OAuth requests |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).resource` | string | No | Enter the URI that represents the resource the client is trying to access. In some cases, it defines the target for access token issuance. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).customFieldName` | string | No | Define the name of the custom parameter that may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).defaultExpirationSeconds` | string | No | Define the default duration (in seconds) that an access token remains valid before it needs to be refreshed or reissued. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).basicNoForm` | boolean | No | If enabled, the client_id and client_secret will not be included in the form data, only grant_type |
| `payload (OAuth 2.0 Two-Legged without secrets) (Resource owner password credentials).excludeRedirectUri` | boolean | No | If enabled, the `redirect_uri` parameter will be excluded in the token request. This parameter is not used by most 2-legged OAuth flows, but is included by default for legacy reasons. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).grantType` | string | Yes | Value: custom |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).customGrantType` | string | Yes | Define a non-standard grant type used for obtaining access tokens. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).grantTypeName` | string | No | Enter the parameter name used to specify the grant type in the access token request body (e.g., grant_type or grantType). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).clientIdName` | string | No | Enter the key name for sending the client ID in a token request (e.g., client_id or clientId). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).clientSecretName` | string | No | Enter the key name for sending the client secret in a token request (e.g., client_secret or clientSecret). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).refreshTokenName` | string | No | Specify the name used to pass a refresh token when requesting a new access token (e.g., refresh_token or refreshToken). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).clientSecret` | string | No | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).accessTokenName` | string | No | Specify the name used to pass the access token in the API request (e.g., access_token or accessToken). It’s typically included in the request header. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).expiresFieldName` | string | No | Define the name of the field that specifies an access token expires (e.g., expires or expires_in). This is used to track when the access token will no longer be valid to make API requests. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).refreshGrantType` | string | No | Specify the grant type used for refreshing an expired token (e.g., refresh_token or refresh). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).contentType` | string | No | Indicate the format of the request body (e.g., application/x-www-form-urlencoded or application/json). |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).noBasic` | string | No | Set to true to suppress sending the auth object in OAuth requests |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).resource` | string | No | Enter the URI that represents the resource the client is trying to access. In some cases, it defines the target for access token issuance. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).customFieldName` | string | No | Define the name of the custom parameter that may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).defaultExpirationSeconds` | string | No | Define the default duration (in seconds) that an access token remains valid before it needs to be refreshed or reissued. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).basicNoForm` | boolean | No | If enabled, the client_id and client_secret will not be included in the form data, only grant_type |
| `payload (OAuth 2.0 Two-Legged without secrets) (Custom grant type).excludeRedirectUri` | boolean | No | If enabled, the `redirect_uri` parameter will be excluded in the token request. This parameter is not used by most 2-legged OAuth flows, but is included by default for legacy reasons. |
| `payload (JWT Bearer without secrets) (HS256).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: HS256 |
| `payload (JWT Bearer without secrets) (HS256).clientSecret` | string | Yes | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `payload (JWT Bearer without secrets) (HS256).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (HS256).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (HS256).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (HS256).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (HS256).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (HS256).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (HS256).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (HS256).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (HS384).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: HS384 |
| `payload (JWT Bearer without secrets) (HS384).clientSecret` | string | Yes | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `payload (JWT Bearer without secrets) (HS384).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (HS384).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (HS384).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (HS384).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (HS384).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (HS384).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (HS384).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (HS384).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (HS512).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: HS512 |
| `payload (JWT Bearer without secrets) (HS512).clientSecret` | string | Yes | Provide the confidential key for authenticating the client application. It’s like a password for the app, which is required in cases where the client must prove its identity. |
| `payload (JWT Bearer without secrets) (HS512).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (HS512).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (HS512).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (HS512).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (HS512).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (HS512).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (HS512).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (HS512).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (RS256).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: RS256 |
| `payload (JWT Bearer without secrets) (RS256).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (RS256).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (RS256).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (RS256).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (RS256).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (RS256).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (RS256).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (RS256).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (RS256).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (RS256).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (RS256).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (RS384).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: RS384 |
| `payload (JWT Bearer without secrets) (RS384).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (RS384).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (RS384).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (RS384).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (RS384).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (RS384).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (RS384).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (RS384).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (RS384).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (RS384).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (RS384).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (RS512).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: RS512 |
| `payload (JWT Bearer without secrets) (RS512).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (RS512).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (RS512).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (RS512).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (RS512).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (RS512).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (RS512).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (RS512).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (RS512).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (RS512).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (RS512).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (PS256).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: PS256 |
| `payload (JWT Bearer without secrets) (PS256).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (PS256).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (PS256).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (PS256).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (PS256).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (PS256).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (PS256).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (PS256).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (PS256).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (PS256).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (PS256).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (PS384).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: PS384 |
| `payload (JWT Bearer without secrets) (PS384).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (PS384).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (PS384).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (PS384).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (PS384).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (PS384).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (PS384).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (PS384).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (PS384).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (PS384).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (PS384).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (PS512).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: PS512 |
| `payload (JWT Bearer without secrets) (PS512).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (PS512).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (PS512).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (PS512).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (PS512).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (PS512).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (PS512).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (PS512).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (PS512).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (PS512).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (PS512).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (ES256).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: ES256 |
| `payload (JWT Bearer without secrets) (ES256).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (ES256).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (ES256).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (ES256).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (ES256).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (ES256).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (ES256).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (ES256).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (ES256).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (ES256).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (ES256).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (ES384).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: ES384 |
| `payload (JWT Bearer without secrets) (ES384).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (ES384).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (ES384).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (ES384).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (ES384).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (ES384).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (ES384).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (ES384).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (ES384).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (ES384).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (ES384).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (JWT Bearer without secrets) (ES512).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Value: ES512 |
| `payload (JWT Bearer without secrets) (ES512).privateKey` | string | Yes | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (JWT Bearer without secrets) (ES512).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (JWT Bearer without secrets) (ES512).clientCert` | string | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (JWT Bearer without secrets) (ES512).clientCertKey` | string | No | Provide the private key associated with the client certificate. |
| `payload (JWT Bearer without secrets) (ES512).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (JWT Bearer without secrets) (ES512).url` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (JWT Bearer without secrets) (ES512).expirationSeconds` | number or null | No | Indicate how long a JWT generated by the JWT Bearer strategy will be valid for. |
| `payload (JWT Bearer without secrets) (ES512).subject` | string | No | Specify the subject (sub) claim for the JWT. This identifies the principal that is the subject of the JWT. When not provided, defaults to the Client ID. |
| `payload (JWT Bearer without secrets) (ES512).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (JWT Bearer without secrets) (ES512).includeJKU` | boolean | No | Set to true if JKU header should be included in generated JWT. |
| `payload (JWT Bearer without secrets) (ES512).includeBodyHash` | boolean | No | If enabled, the signed JWT will include a body_sha256 claim containing a base64url-encoded SHA-256 hash of the raw request body for integrity verification. |
| `payload (Google Workload Identity Federation).audience` | string | Yes | Indicates the system that should consume the authentication credentials. This field isn't required but is sent in the `audience` field of the authorization request when populated. |
| `payload (Google Workload Identity Federation).delegates` | string | Yes | Designates the system that must provide the final access token in the authentication workflow. |
| `payload (Google Workload Identity Federation).lifetime` | string | Yes | Specifies the length of time that the delegated credentials are valid, typically in number of seconds. |
| `payload (Google Workload Identity Federation).scope` | string | Yes | Defines the scope or access granted with the authentication credentials. |
| `payload (Google Workload Identity Federation).service_account_impersonation_url` | string | Yes | Contains the URL (provided by the external identity provider) that a system uses to impersonate the service account in order to get access. |
| `payload (Google Workload Identity Federation).id` | string | Yes | Contains a unique identifier assigned to the auth credential. Use this value when querying for this auth credential in future API requests. |
| `payload (Google Workload Identity Federation).createdAt` | string | Yes | Displays the timestamp of when the auth credential was created. This value is set by Redox. |
| `payload (Google Workload Identity Federation).updatedAt` | string | Yes | Displays the timestamp of the last time this auth credential was updated. This value is set by Redox. |
| `payload (Google Workload Identity Federation).options` | string or null | No | Defines an additional set of features that the Security Token Service supports. |
| `payload (Google Workload Identity Federation).sts_scope` | string | No | Defines the scope or access granted by the Security Token Service. |
| `payload (Google Workload Identity Federation).token_url` | string | No | Contains the endpoint URL for the GCP Security Token Service. |
| `payload (SMART Backend without secrets).organization` | number | Yes | Contains your unique Redox organization identifier. |
| `payload (SMART Backend without secrets).name` | string | Yes | Displays the name of the auth credential. |
| `payload (SMART Backend without secrets).environmentId` | string | Yes | Identifies the specific environment that the auth credential is used in. |
| `payload (SMART Backend without secrets).grantType` | string | Yes | Define the method used to obtain the access token. Depending on the auth strategy, it’s common to use client_credentials or password. Value: client_credentials |
| `payload (SMART Backend without secrets).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Possible values: HS256, HS384, HS512, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384, ES512 |
| `payload (SMART Backend without secrets).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `payload (SMART Backend without secrets).id` | string | Yes | Contains a unique identifier assigned to the auth credential. Use this value when querying for this auth credential in future API requests. |
| `payload (SMART Backend without secrets).createdAt` | string | Yes | Displays the timestamp of when the auth credential was created. This value is set by Redox. |
| `payload (SMART Backend without secrets).updatedAt` | string | Yes | Displays the timestamp of the last time this auth credential was updated. This value is set by Redox. |
| `payload (SMART Backend without secrets).privateKey` | string | No | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |
| `payload (SMART Backend without secrets).keyId` | string | No | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (SMART Backend without secrets).clientCert` | Option 1 or Option 2 | No | Provide a digital certificate used to authenticate the client to the server. The client certificate proves the identity of the client in mutual TLS authentication to ensure a secure connection. |
| `payload (SMART Backend without secrets).clientCert (Option 1)` | string (uuid) | No |  |
| `payload (SMART Backend without secrets).clientCert (Option 2)` | string | No | Value:  |
| `payload (SMART Backend without secrets).clientCertKey` | Option 1 or Option 2 | No | Provide a digital certificate key used to authenticate the client to the server. This key is paired with the client certificate. |
| `payload (SMART Backend without secrets).clientCertKey (Option 1)` | string (uuid) | No |  |
| `payload (SMART Backend without secrets).clientCertKey (Option 2)` | string | No | Value:  |
| `payload (SMART Backend without secrets).tokenHeader` | string | No | Enter a custom header name for the bearer token (e.g. X-ACCESS). If set, the bearer token will go in this header instead of the Authorization header. |
| `payload (SMART Backend without secrets).includeX5t` | boolean | No | If enabled, JWTs generated by the JWT Bearer strategy will include the x5t header |
| `payload (SMART Backend without secrets).includeJKU` | boolean | No | If enabled, JWTs generated by the strategy will include the jku header. |
| `payload (SMART Backend without secrets).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (SMART Backend without secrets).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `payload (SMART Backend without secrets).customFieldValue` | string | No | Specify the value for the custom parameter, which may be required by a specific implementation. Used by Redox for advanced configurations. |
| `payload (SMART Backend without secrets).caCertificateChain` | string | No | Provide a custom Certificate Authority (CA) chain in PEM format for validating the server certificate. Use this when connecting to servers with self-signed or private CA certificates that are not in the system trust store. Multiple certificates should be concatenated together. |
| `payload (SMART Backend without secrets).authStrategy` | string | No | Indicates the specific strategy type that this auth credential belongs to. Value: SMART_Backend |
| `payload (SMART Backend without secrets).hasPrivateKey` | boolean | No | Indicates if a private key is stored in the auth credential. If so, this is set to `true`. |
| `payload (AWS Signature Version 4 without sercrets).id` | string | Yes | Contains a unique identifier assigned to the auth credential. Use this value when querying for this auth credential in future API requests. |
| `payload (AWS Signature Version 4 without sercrets).createdAt` | string | Yes | Displays the timestamp of when the auth credential was created. This value is set by Redox. |
| `payload (AWS Signature Version 4 without sercrets).updatedAt` | string | Yes | Displays the timestamp of the last time this auth credential was updated. This value is set by Redox. |
| `payload (AWS Signature Version 4 without sercrets).hasSecretKey` | boolean | Yes | Indicates if the secret key are stored in the auth credential. If so, this is set to `true`. |
| `payload (AWS Signature Version 4 without sercrets).accessKey` | string | Yes | Contains the key used in conjunction with AWS SigV4 authentication to identify the user or system making the API request. |
| `payload (AWS Signature Version 4 without sercrets).awsRegion` | string | Yes | Indicates the AWS region the service is in. (e.g., default is us-east-1). |
| `payload (AWS Signature Version 4 without sercrets).serviceName` | string | Yes | Indicates the AWS service name to connect to (e.g., default is healthlake). |
| `payload (AWS Signature Version 4 without sercrets).sessionToken` | string | No | Contains a temporary access token used in AWS SigV4 authentication to authenticate API requests when using temporary security credentials. |
| `payload (OAuth 2.0 JWT GCP without private keys).id` | string | Yes | Contains a unique identifier assigned to the auth credential. Use this value when querying for this auth credential in future API requests. |
| `payload (OAuth 2.0 JWT GCP without private keys).createdAt` | string | Yes | Displays the timestamp of when the auth credential was created. This value is set by Redox. |
| `payload (OAuth 2.0 JWT GCP without private keys).updatedAt` | string | Yes | Displays the timestamp of the last time this auth credential was updated. This value is set by Redox. |
| `payload (OAuth 2.0 JWT GCP without private keys).organization` | number | Yes | Contains your unique Redox organization identifier. |
| `payload (OAuth 2.0 JWT GCP without private keys).name` | string | Yes | Displays the name of the auth credential. |
| `payload (OAuth 2.0 JWT GCP without private keys).environmentId` | string | Yes | Identifies the specific environment that the auth credential is used in. |
| `payload (OAuth 2.0 JWT GCP without private keys).url` | string | Yes | Enter the URL where the client requests an access token. It’s usually provided by the authorization server and varies by auth strategy. Redox passes credentials to this URL for auth strategies other than OAuth. For SAML/SOAP auth, this may not be used. |
| `payload (OAuth 2.0 JWT GCP without private keys).keyId` | string | Yes | Enter an identifier that references the private key to sign the JWT. It’s typically included in the JWT header to let the recipient know which key to use for verification. |
| `payload (OAuth 2.0 JWT GCP without private keys).algorithm` | string | Yes | Specify the algorithm used to sign the JWT token. RS256 and HS256 are most common (reference: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1) Possible values: HS256, HS384, HS512, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384, ES512 |
| `payload (OAuth 2.0 JWT GCP without private keys).authStrategy` | string | Yes | Indicates the specific strategy type that this auth credential belongs to. Value: OAuth_2.0_JWT_GCP |
| `payload (OAuth 2.0 JWT GCP without private keys).hasPrivateKey` | boolean | Yes | Indicates if the private key is stored in the auth credential. If so, this is set to `true`. |
| `payload (OAuth 2.0 JWT GCP without private keys).customGrantType` | string | No | Set this to override the default `urn:ietf:params:oauth:grant-type:jwt-bearer` grant type expected by GCP |
| `payload (OAuth 2.0 JWT GCP without private keys).clientId` | string | No | Provide the unique identifier assigned to a client application by the authorization server. This identifies which application is making the authentication request. |
| `payload (OAuth 2.0 JWT GCP without private keys).audience` | string | No | Specify the intended recipient of the access token. This is typically the URI of the resource server. |
| `payload (OAuth 2.0 JWT GCP without private keys).scopes` | string | No | Define what permissions the application is requesting from the user. In some cases, scopes limit access to specific resources or actions. |
| `payload (OAuth 2.0 JWT GCP without private keys).privateKey` | string | No | Provide a cryptographic key for signing access tokens or verifying data integrity. For JWT Bearer or SMART Backend, the private key is used to sign the JWT token. |

_Generated from the schema: the values are placeholders, not a real payload._

```json
{
  "meta": {
    "version": "1.0.0"
  },
  "payload": {
    "id": "string",
    "createdAt": "string",
    "updatedAt": "string",
    "hasClientSecret": "",
    "organization": 118,
    "name": "Sample Auth Credential",
    "environmentId": "a31a92e5-43b7-45df-8085-4ac5a746d105",
    "grantType": "client_credentials",
    "url": "string",
    "grantTypeName": "grant_type",
    "clientIdName": "client_id",
    "clientSecretName": "client_secret",
    "refreshTokenName": "refresh_token",
    "clientId": "string",
    "clientSecret": "string",
    "accessTokenName": "string",
    "expiresFieldName": "string",
    "refreshGrantType": "string",
    "audience": "string",
    "scopes": "string",
    "contentType": "string",
    "noBasic": "string",
    "resource": "string",
    "customFieldName": "string",
    "customFieldValue": "string",
    "defaultExpirationSeconds": "string",
    "caCertificateChain": "string",
    "basicNoForm": true,
    "excludeRedirectUri": true,
    "authStrategy": "OAuth_2.0_2-legged"
  }
}
```

### 400

Bad Request

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `payload` | object | No | Contains the error message. |
| `payload.error` | object | No | Contains the error message details. |
| `payload.error.title` | string | No | Displays the high-level error message, typically something succinct like `Bad Request`. |
| `payload.error.code` | string | No | Contains an alternative ID for the error type, which can be used to find relevant troubleshooting information. |
| `payload.error.detail` | string | No | Contains the specific error details for this message. |
| `payload.error.status` | number | No | Displays the corresponding HTTP status code for the error. |
| `payload.error.transient` | boolean | No | Describes whether the error will resolve itself. If `true`, no further action needs to be taken. If `false`, you may need to troubleshoot on your end to resolve the issue before the error can be processed. |

```json
{
  "payload": {
    "error": {
      "title": "Bad Request",
      "code": "validation.error.bad.request",
      "detail": "Error details",
      "status": 400,
      "transient": false
    }
  }
}
```
