Skip to main content


Logging in and out​

Qiata uses OAuth2/OpenID Connect as default login mechanism.


We currently support Authorization Code Flow with Proof Key for Code Exchange (PKCE) and Client Credentials Grant

You can use the official certified Relying Party Libraries to implement and ensure you create a secure login flow.

You can try to use non certified libraries or implement the login yourself, but keep in mind we cannot support or ensure security this way. You take full responsibility.

Qiata also fulfills the role of beeing a Custom Authorization Server/Identity Provider for OIDC. If you authenticate with OIDC against Qiata, local and LDAP Accounts can be used.

Qiata also offers to configure a third party Authorization Server/remote Identity Provider (IDP). Currently AzureAD and ADFS 4.0 are supported.
If it is configured on your Qiata, you can configure your application to use this Identity Provider. Users can then login with their Microsoft Accounts.


Qiata offers URI Discovery Mechanism for the Provider Configuration URI to provide all informations for the local Identity Provider https://FQDN/.well-known/openid-configuration

Example openid-configuration​

"issuer": "",
"authorization_endpoint": "",
"token_endpoint": "",
"jwks_uri": "",
"subject_types_supported": [
"response_types_supported": [
"code id_token",
"token id_token",
"token id_token code"
"claims_supported": [
"grant_types_supported": [
"response_modes_supported": [
"userinfo_endpoint": "",
"scopes_supported": [
"token_endpoint_auth_methods_supported": [
"userinfo_signing_alg_values_supported": [
"id_token_signing_alg_values_supported": [
"request_parameter_supported": true,
"request_uri_parameter_supported": true,
"require_request_uri_registration": true,
"claims_parameter_supported": false,
"revocation_endpoint": "",
"backchannel_logout_supported": true,
"backchannel_logout_session_supported": true,
"frontchannel_logout_supported": true,
"frontchannel_logout_session_supported": true,
"end_session_endpoint": "",
"request_object_signing_alg_values_supported": [
"code_challenge_methods_supported": [

OIDCinfo Endpoint​

On top, a non-standardized endpoint offers additional informations, you may need to configure your application or used libraries.


This endpoint only offers the enabled Client-Configurations.


As an indicator, each client has the isLocal property, to differentiate between Qiatas local IDP and remote IDPs like AzureAD/ADFS.

Other details like ClientID, IssuerURL, postLogoutRedirectURI and required Scopes are also offered.

The property EmailClaim is the Claim Name inside the AccessToken, that must hold the Email Address of the authenticated user. This EmailAddress is used to uniquely identify users.

To further communicate with XMLAPI after successfull authentication you need to pass Access-Token, CSRF-Token and FTAuser Cookie.

Acquire an Access Token and a Refresh Token​

You can use Code Flow with PKCE or client credentials grant if available to get new Tokens.

Code Flow (PKCE)​


We recommend, that you use a certified OIDC library.

For Code Flow the required informations can be found in the OIDCinfo Endpoints.

Authority maps to IssuerURL.
RedirectURL is https://QIATAFQDN/v2/login/
PostLogoutRedirectURI maps to PostLogout.

Usually the library then handles Access_Token and refreshing Tokens with Refresh_Token
When you receive the tokens, the response also contains the information how long they are valid.


In case of local provider Qiata. The Access_Token is valid for 10 minutes and the Refresh_Token is valid for 15 minutes.
The tokens lifetime of other providers may be different. Check with your provider.

Currently you cannot change RedirectURL oder PostLogoutURI.

OIDC Custom App / Client credentials grant​

We also offer the authentication configuration of OIDC client_credentials grant for custom apps.


A license key with the feature OpenID Custom App is required.

When authenticating with this client/custom app, it will act on behalf of the selected User Account.
In this case, you will only get Access Tokens and only the local Provider (Qiata) can be used.

Configuration can be done as Primary Company administrator.

New OIDC Provider

Log in to the system as Company Administrator.

  1. Company.

Navigate to the item Company

  1. OpenID Connect Custom App

Navigate to the item OpenID Connect Custom App

  1. OpenID Connect Custom App Configuration

Now fill out the form.
Provide a Name, Client Secret and select the associated User Account. You can type in, to filter the selection.


Keep your Client Secret safe. After saving, the Client Secret is not available in plaintext anymore.

  1. Save

Finally save your configuration.

After some time, the forms provides you with a new ClientID.


If your Client secret got compromised, you should save a new one as soon as possible.
Or Remove the entire configuration. Or shutdown Qiata.

Example POST - Prerequisites to use XMLAPI​

First Step: Receive Access Token​

Provide ClientID and ClientSecret​
curl --request POST \
--url 'https://QIATAFQDN/oauth2/token' \
--header 'content-type: application/x-www-form-urlencoded' \
--data grand_type=client_credentials \
--data client_id=CUSTOMAPP_CLIENTID \
--data client_secret=CUSTOMAPP_CLIENTSECRET
curl --request GET \
--url 'https://QIATAFQDN/v2/csrf' \
--cookie-jar CSRFCookies
Provide Access Token, CSRFCookies and set xmllogin to true​
curl --request POST \
--url 'https://QIATAFQDN/v2/qiata' \
--cookie CSRFCookies \
--cookie-jar FTACookie \
--data "xmllogin=true" \

Acquire a CSRF-Token​

Send a GET request to https://FQDN/v2/csrf

Extract the Cookie csrf_token.


Use this Token on all POST Requests to https://FQDN/v2 endpoints. The Token can be send in different ways to the endpoint:

  • request header: X-CSRF-Token
  • POST value: csrf_token
  • Cookie: csrf_token

Acquire the FTAUserCookie​

After the OIDC login and before the user can use Qiata functions the user has to be authorized by the Qiata. The authorization returns a Cookie FTAUser, which has to be send with any requests to https://FQDN/v2/fta.

The authorization endpoint is https://FQDN/v2/qiata. Send a POST request with the following values to it:

  • at: the current access token
  • xmllogin: true
  • usersonly: true
  • tkey: notneeded

The Response contains an XML-structure with a status value and a possible errormessage on failure. Within the Response the server has set the Cookie FTAUser.