Auth

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/accounts/acc123/auth-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/accounts/{account_id}/auth-templates

Create a reusable hosted auth template for an account. More

Bodyapplication/json

namestringrequired

screen_typerequired

body_html_templatestringrequired

Responses

200application/json

schemaobject

dataAuthTemplaterequired

A reusable hosted auth template for a specific screen type.

idstringrequired

Unique identifier for a hosted auth template.

account_idstringrequired

Unique identifier for an account.

namestringrequired

screen_typerequired

body_html_templatestringrequired

archived_atstring | null

linksobjectrequired

selfstringrequired

URL of the created resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/accounts/acc123/auth-templates" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"name":"string","screen_type":"login","body_html_template":"string"}'

const payload = {"name":"string","screen_type":"login","body_html_template":"string"};
const url = "${BASE_URL}/api/accounts/acc123/auth-templates";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"name":"string","screen_type":"login","body_html_template":"string"};
const url = "${BASE_URL}/api/accounts/acc123/auth-templates";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"name":"string","screen_type":"login","body_html_template":"string"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/accounts/acc123/auth-templates",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"name":"string","screen_type":"login","body_html_template":"string"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/accounts/acc123/auth-templates",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"name":"string","screen_type":"login","body_html_template":"string"};
const { body } = await request("${BASE_URL}/api/accounts/acc123/auth-templates", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"name":"string","screen_type":"login","body_html_template":"string"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/accounts/acc123/auth-templates", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"name":"string","screen_type":"login","body_html_template":"string"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/accounts/acc123/auth-templates", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"name":"string","screen_type":"login","body_html_template":"string"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/accounts/acc123/auth-templates", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"name":"string","screen_type":"login","body_html_template":"string"}
uri = URI("${BASE_URL}/api/accounts/acc123/auth-templates")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"name":"string","screen_type":"login","body_html_template":"string"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/accounts/acc123/auth-templates", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/accounts/acc123/auth-templates");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"name\":\"string\",\"screen_type\":\"login\",\"body_html_template\":\"string\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/accounts/{account_id}/auth-templates/search

Search hosted auth templates for an account using Lucene syntax. More

Bodyapplication/json

querystringrequired

limitinteger

offsetinteger

sort

Responses

200application/json

schemaobject

dataarrayrequired

itemAuthTemplaterequired

A reusable hosted auth template for a specific screen type.

idstringrequired

Unique identifier for a hosted auth template.

account_idstringrequired

Unique identifier for an account.

namestringrequired

screen_typerequired

body_html_templatestringrequired

archived_atstring | null

metaobjectrequired

querystringrequired

totalnumberrequired

limitnumberrequired

offsetnumberrequired

sortrequired

linksobjectrequired

selfstringrequired

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/accounts/acc123/auth-templates/search" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}'

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const url = "${BASE_URL}/api/accounts/acc123/auth-templates/search";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const url = "${BASE_URL}/api/accounts/acc123/auth-templates/search";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/accounts/acc123/auth-templates/search",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/accounts/acc123/auth-templates/search",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const { body } = await request("${BASE_URL}/api/accounts/acc123/auth-templates/search", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/accounts/acc123/auth-templates/search", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/accounts/acc123/auth-templates/search", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/accounts/acc123/auth-templates/search", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}
uri = URI("${BASE_URL}/api/accounts/acc123/auth-templates/search")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/accounts/acc123/auth-templates/search", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/accounts/acc123/auth-templates/search");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"query\":\"string\",\"limit\":123,\"offset\":123,\"sort\":\"created_at:desc,id:asc\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE/api/application-authority-templates/{application_authority_template_id}

Delete one hosted auth screen binding. More

Responses

204

Deleted

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X DELETE \\
  "${BASE_URL}/api/application-authority-templates/aat123" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/application-authority-templates/aat123";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/application-authority-templates/aat123";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "delete",
  url: "${BASE_URL}/api/application-authority-templates/aat123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "delete",
  url: "${BASE_URL}/api/application-authority-templates/aat123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/application-authority-templates/aat123", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "DELETE", \
    "${BASE_URL}/api/application-authority-templates/aat123", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "DELETE", \
        "${BASE_URL}/api/application-authority-templates/aat123", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("DELETE", "${BASE_URL}/api/application-authority-templates/aat123", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/application-authority-templates/aat123")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("DELETE", "${BASE_URL}/api/application-authority-templates/aat123", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "${BASE_URL}/api/application-authority-templates/aat123");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/application-authority-templates/{application_authority_template_id}

Get one hosted auth screen binding by ID. More

Responses

200application/json

schemaobject

dataApplicationAuthorityTemplaterequired

Maps one hosted auth screen type to one auth template for a specific application authority.

idstringrequired

Unique identifier for an application authority template binding.

application_idstringrequired

Unique identifier for an application.

screen_typerequired

template_idstringrequired

Unique identifier for a hosted auth template.

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/application-authority-templates/aat123" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/application-authority-templates/aat123";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/application-authority-templates/aat123";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/application-authority-templates/aat123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/application-authority-templates/aat123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/application-authority-templates/aat123", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/application-authority-templates/aat123", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/application-authority-templates/aat123", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/application-authority-templates/aat123", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/application-authority-templates/aat123")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/application-authority-templates/aat123", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/application-authority-templates/aat123");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH/api/application-authority-templates/{application_authority_template_id}

Update one hosted auth screen binding. More

Bodyapplication/json

screen_type

template_idstring | null

Unique identifier for a hosted auth template.

Responses

200application/json

schemaobject

dataApplicationAuthorityTemplaterequired

Maps one hosted auth screen type to one auth template for a specific application authority.

idstringrequired

Unique identifier for an application authority template binding.

application_idstringrequired

Unique identifier for an application.

screen_typerequired

template_idstringrequired

Unique identifier for a hosted auth template.

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X PATCH \\
  "${BASE_URL}/api/application-authority-templates/aat123" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '"value"'

const payload = "value";
const url = "${BASE_URL}/api/application-authority-templates/aat123";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = "value";
const url = "${BASE_URL}/api/application-authority-templates/aat123";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = "value";
const response = await axios({
  method: "patch",
  url: "${BASE_URL}/api/application-authority-templates/aat123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = "value";
const response: AxiosResponse = await axios({
  method: "patch",
  url: "${BASE_URL}/api/application-authority-templates/aat123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = "value";
const { body } = await request("${BASE_URL}/api/application-authority-templates/aat123", {
  method: "PATCH",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = "value"
response = requests.request( \
    "PATCH", \
    "${BASE_URL}/api/application-authority-templates/aat123", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = "value"
with httpx.Client() as client:
    response = client.request( \
        "PATCH", \
        "${BASE_URL}/api/application-authority-templates/aat123", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`"value"`))

req, err := http.NewRequest("PATCH", "${BASE_URL}/api/application-authority-templates/aat123", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = "value"
uri = URI("${BASE_URL}/api/application-authority-templates/aat123")
request = Net::HTTP::Patch.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = "value";
$client = new Client();
$response = $client->request("PATCH", "${BASE_URL}/api/application-authority-templates/aat123", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "${BASE_URL}/api/application-authority-templates/aat123");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("\"value\"", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/applications/{application_id}/authority

Get the public auth authority configuration for an application. More

Responses

200application/json

schemaobject

dataApplicationAuthorityrequired

Application-owned public auth authority. Owns application-level hosted auth configuration, keys, and branding.

application_idstringrequired

Unique identifier for an application.

authority_domain_idstringrequired

Unique identifier for an application-domain link.

branding_configobjectrequired

hosted_sso_configobjectrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/applications/app123/authority" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/authority";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/authority";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/authority",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/authority",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/authority", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/applications/app123/authority", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/applications/app123/authority", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/applications/app123/authority", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/authority")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/applications/app123/authority", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/applications/app123/authority");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH/api/applications/{application_id}/authority

Update the hosted auth configuration for an application authority. More

Bodyapplication/json

authority_domain_idstring | null

Unique identifier for an application-domain link.

branding_configobject | null

hosted_sso_configobject | null

Responses

200application/json

schemaobject

dataApplicationAuthorityrequired

Application-owned public auth authority. Owns application-level hosted auth configuration, keys, and branding.

application_idstringrequired

Unique identifier for an application.

authority_domain_idstringrequired

Unique identifier for an application-domain link.

branding_configobjectrequired

hosted_sso_configobjectrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X PATCH \\
  "${BASE_URL}/api/applications/app123/authority" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '"value"'

const payload = "value";
const url = "${BASE_URL}/api/applications/app123/authority";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = "value";
const url = "${BASE_URL}/api/applications/app123/authority";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = "value";
const response = await axios({
  method: "patch",
  url: "${BASE_URL}/api/applications/app123/authority",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = "value";
const response: AxiosResponse = await axios({
  method: "patch",
  url: "${BASE_URL}/api/applications/app123/authority",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = "value";
const { body } = await request("${BASE_URL}/api/applications/app123/authority", {
  method: "PATCH",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = "value"
response = requests.request( \
    "PATCH", \
    "${BASE_URL}/api/applications/app123/authority", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = "value"
with httpx.Client() as client:
    response = client.request( \
        "PATCH", \
        "${BASE_URL}/api/applications/app123/authority", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`"value"`))

req, err := http.NewRequest("PATCH", "${BASE_URL}/api/applications/app123/authority", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = "value"
uri = URI("${BASE_URL}/api/applications/app123/authority")
request = Net::HTTP::Patch.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = "value";
$client = new Client();
$response = $client->request("PATCH", "${BASE_URL}/api/applications/app123/authority", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "${BASE_URL}/api/applications/app123/authority");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("\"value\"", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/applications/{application_id}/authority-templates

List hosted auth screen bindings for an application authority. More

Responses

200application/json

schemaobject

dataarrayrequired

itemApplicationAuthorityTemplaterequired

Maps one hosted auth screen type to one auth template for a specific application authority.

idstringrequired

Unique identifier for an application authority template binding.

application_idstringrequired

Unique identifier for an application.

screen_typerequired

template_idstringrequired

Unique identifier for a hosted auth template.

linksobjectrequired

selfstringrequired

URL of the current page

nextstring

URL of the next page

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/applications/app123/authority-templates?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/applications/{application_id}/authority-templates

Bind one hosted auth screen type to one auth template for an application authority. More

Bodyapplication/json

screen_typerequired

template_idstringrequired

Unique identifier for a hosted auth template.

Responses

200application/json

schemaobject

dataApplicationAuthorityTemplaterequired

Maps one hosted auth screen type to one auth template for a specific application authority.

idstringrequired

Unique identifier for an application authority template binding.

application_idstringrequired

Unique identifier for an application.

screen_typerequired

template_idstringrequired

Unique identifier for a hosted auth template.

linksobjectrequired

selfstringrequired

URL of the created resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/applications/app123/authority-templates" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"screen_type":"login","template_id":"aut123"}'

const payload = {"screen_type":"login","template_id":"aut123"};
const url = "${BASE_URL}/api/applications/app123/authority-templates";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"screen_type":"login","template_id":"aut123"};
const url = "${BASE_URL}/api/applications/app123/authority-templates";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"screen_type":"login","template_id":"aut123"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/authority-templates",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"screen_type":"login","template_id":"aut123"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/authority-templates",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"screen_type":"login","template_id":"aut123"};
const { body } = await request("${BASE_URL}/api/applications/app123/authority-templates", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"screen_type":"login","template_id":"aut123"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/applications/app123/authority-templates", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"screen_type":"login","template_id":"aut123"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/applications/app123/authority-templates", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"screen_type":"login","template_id":"aut123"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/applications/app123/authority-templates", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"screen_type":"login","template_id":"aut123"}
uri = URI("${BASE_URL}/api/applications/app123/authority-templates")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"screen_type":"login","template_id":"aut123"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/applications/app123/authority-templates", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/applications/app123/authority-templates");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"screen_type\":\"login\",\"template_id\":\"aut123\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/applications/{application_id}/authority-templates/search

Search hosted auth screen bindings for an application authority using Lucene syntax. More

Bodyapplication/json

querystringrequired

limitinteger

offsetinteger

sort

Responses

200application/json

schemaobject

dataarrayrequired

itemApplicationAuthorityTemplaterequired

Maps one hosted auth screen type to one auth template for a specific application authority.

idstringrequired

Unique identifier for an application authority template binding.

application_idstringrequired

Unique identifier for an application.

screen_typerequired

template_idstringrequired

Unique identifier for a hosted auth template.

metaobjectrequired

querystringrequired

totalnumberrequired

limitnumberrequired

offsetnumberrequired

sortrequired

linksobjectrequired

selfstringrequired

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/applications/app123/authority-templates/search" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}'

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const url = "${BASE_URL}/api/applications/app123/authority-templates/search";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const url = "${BASE_URL}/api/applications/app123/authority-templates/search";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/authority-templates/search",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/authority-templates/search",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
const { body } = await request("${BASE_URL}/api/applications/app123/authority-templates/search", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/applications/app123/authority-templates/search", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/applications/app123/authority-templates/search", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/applications/app123/authority-templates/search", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"}
uri = URI("${BASE_URL}/api/applications/app123/authority-templates/search")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/applications/app123/authority-templates/search", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/applications/app123/authority-templates/search");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"query\":\"string\",\"limit\":123,\"offset\":123,\"sort\":\"created_at:desc,id:asc\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/applications/{application_id}/authority/keys

List the public signing keys for an application authority. More

Responses

200application/json

schemaobject

dataarrayrequired

itemApplicationAuthorityKeyrequired

A public signing key owned by an application authority and used for auth token verification.

kidstringrequired

application_idstringrequired

Unique identifier for an application.

jwkrequired

public_keystringrequired

linksobjectrequired

selfstringrequired

URL of the current page

nextstring

URL of the next page

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/applications/app123/authority/keys" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/authority/keys";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/authority/keys";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/authority/keys",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/authority/keys",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/authority/keys", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/applications/app123/authority/keys", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/applications/app123/authority/keys", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/applications/app123/authority/keys", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/authority/keys")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/applications/app123/authority/keys", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/applications/app123/authority/keys");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/applications/{application_id}/authority/keys

Generate a new signing key pair for an application authority. More

Bodyapplication/json

bodyobjectrequired

Responses

200application/json

schemaobject

dataApplicationAuthorityKeyrequired

A public signing key owned by an application authority and used for auth token verification.

kidstringrequired

application_idstringrequired

Unique identifier for an application.

jwkrequired

public_keystringrequired

linksobjectrequired

selfstringrequired

URL of the created resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/applications/app123/authority/keys" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{}'

const payload = {};
const url = "${BASE_URL}/api/applications/app123/authority/keys";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {};
const url = "${BASE_URL}/api/applications/app123/authority/keys";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/authority/keys",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/authority/keys",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {};
const { body } = await request("${BASE_URL}/api/applications/app123/authority/keys", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/applications/app123/authority/keys", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/applications/app123/authority/keys", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/applications/app123/authority/keys", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {}
uri = URI("${BASE_URL}/api/applications/app123/authority/keys")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/applications/app123/authority/keys", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/applications/app123/authority/keys");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE/api/applications/{application_id}/authority/keys/{kid}

Delete one application authority signing key by kid. More

Responses

204

Deleted

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X DELETE \\
  "${BASE_URL}/api/applications/app123/authority/keys/string" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/authority/keys/string";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/authority/keys/string";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "delete",
  url: "${BASE_URL}/api/applications/app123/authority/keys/string",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "delete",
  url: "${BASE_URL}/api/applications/app123/authority/keys/string",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/authority/keys/string", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "DELETE", \
    "${BASE_URL}/api/applications/app123/authority/keys/string", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "DELETE", \
        "${BASE_URL}/api/applications/app123/authority/keys/string", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("DELETE", "${BASE_URL}/api/applications/app123/authority/keys/string", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/authority/keys/string")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("DELETE", "${BASE_URL}/api/applications/app123/authority/keys/string", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "${BASE_URL}/api/applications/app123/authority/keys/string");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE/api/auth-templates/{auth_template_id}

Delete a hosted auth template. More

Responses

204

Deleted

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

404application/problem+jsonProblemDetails

Not Found

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X DELETE \\
  "${BASE_URL}/api/auth-templates/aut123" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/auth-templates/aut123";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/auth-templates/aut123";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "delete",
  url: "${BASE_URL}/api/auth-templates/aut123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "delete",
  url: "${BASE_URL}/api/auth-templates/aut123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/auth-templates/aut123", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "DELETE", \
    "${BASE_URL}/api/auth-templates/aut123", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "DELETE", \
        "${BASE_URL}/api/auth-templates/aut123", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("DELETE", "${BASE_URL}/api/auth-templates/aut123", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/auth-templates/aut123")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("DELETE", "${BASE_URL}/api/auth-templates/aut123", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "${BASE_URL}/api/auth-templates/aut123");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/auth-templates/{auth_template_id}

Get a hosted auth template by ID. More

Responses

200application/json

schemaobject

dataAuthTemplaterequired

A reusable hosted auth template for a specific screen type.

idstringrequired

Unique identifier for a hosted auth template.

account_idstringrequired

Unique identifier for an account.

namestringrequired

screen_typerequired

body_html_templatestringrequired

archived_atstring | null

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/auth-templates/aut123" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/auth-templates/aut123";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/auth-templates/aut123";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/auth-templates/aut123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/auth-templates/aut123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/auth-templates/aut123", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/auth-templates/aut123", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/auth-templates/aut123", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/auth-templates/aut123", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/auth-templates/aut123")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/auth-templates/aut123", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/auth-templates/aut123");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH/api/auth-templates/{auth_template_id}

Update a hosted auth template. More

Bodyapplication/json

namestring | null

screen_type

body_html_templatestring | null

archived_atstring | null

Responses

200application/json

schemaobject

dataAuthTemplaterequired

A reusable hosted auth template for a specific screen type.

idstringrequired

Unique identifier for a hosted auth template.

account_idstringrequired

Unique identifier for an account.

namestringrequired

screen_typerequired

body_html_templatestringrequired

archived_atstring | null

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X PATCH \\
  "${BASE_URL}/api/auth-templates/aut123" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '"value"'

const payload = "value";
const url = "${BASE_URL}/api/auth-templates/aut123";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = "value";
const url = "${BASE_URL}/api/auth-templates/aut123";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = "value";
const response = await axios({
  method: "patch",
  url: "${BASE_URL}/api/auth-templates/aut123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = "value";
const response: AxiosResponse = await axios({
  method: "patch",
  url: "${BASE_URL}/api/auth-templates/aut123",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = "value";
const { body } = await request("${BASE_URL}/api/auth-templates/aut123", {
  method: "PATCH",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = "value"
response = requests.request( \
    "PATCH", \
    "${BASE_URL}/api/auth-templates/aut123", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = "value"
with httpx.Client() as client:
    response = client.request( \
        "PATCH", \
        "${BASE_URL}/api/auth-templates/aut123", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`"value"`))

req, err := http.NewRequest("PATCH", "${BASE_URL}/api/auth-templates/aut123", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = "value"
uri = URI("${BASE_URL}/api/auth-templates/aut123")
request = Net::HTTP::Patch.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = "value";
$client = new Client();
$response = $client->request("PATCH", "${BASE_URL}/api/auth-templates/aut123", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "${BASE_URL}/api/auth-templates/aut123");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("\"value\"", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/{provider}/authorize

Provider-first OAuth authorize entrypoint. Internally forwards to /oauth2/authorize with the provider connection set. More

Responses

303

Redirect

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/google/authorize" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/google/authorize";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/google/authorize";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/google/authorize",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/google/authorize",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/google/authorize", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/google/authorize", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/google/authorize", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/google/authorize", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/google/authorize")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/google/authorize", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/google/authorize");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/{provider}/callback

Provider-first OAuth callback entrypoint. Internally forwards to /oauth2/callback/:provider. More

Responses

303

Redirect

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/google/callback" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/google/callback";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/google/callback";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/google/callback",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/google/callback",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/google/callback", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/google/callback", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/google/callback", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/google/callback", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/google/callback")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/google/callback", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/google/callback");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/accept-invite

Accept an invite to join an account using an invite token. Returns a login response if successful.

Users should receive a url either via email or other means with a unique token param such that following the link accepts the invite.

The invite token stores the client identity used to create the accepted session, so callers should only send the invite token.

An invite is a one-time login, so the client is expected to either present a set password flow, or use email magic links/SSO from then on. More

Responses

200application/jsonAuthenticationResult

The complete result of a successful authentication operation, including tokens and user profile context

tokensSessionTokensrequired

The set of tokens issued to a client upon successful authentication or token refresh

access_tokenAccessTokenrequired

A short-lived JWT access token signed by the authentication service

refresh_tokenRefreshTokenrequired

An opaque long-lived refresh token used to obtain new access tokens. Can be revoked.

token_typeTokenTyperequired

Description of how the access token should be used

expires_inTimestampInSecondsrequired

A Unix timestamp in seconds since the epoch

profileSessionProfilerequired

A user's session profile including their credentials, memberships, identity, and currently active membership context.

idstringrequired

Unique identifier for a user.

application_idstringrequired

Unique identifier for an application.

statusrequired

credentialsarrayrequired

itemEmailCredentialrequired

Nested fields truncated. Expand to continue inline, or use the model link.

Associates an email address with a user for authentication. Used to look up users during login flows and verify email ownership.

membershipsarrayrequired

itemallOfrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

identityUserIdentity | nullUserIdentityrequired

Personal profile information for a user including name, avatar, and locale preferences. Stored separately from authentication data for GDPR compliance.

idstringrequired

Unique identifier for a user.

avatar_urlstring · uri | null

external_idstring | null

given_namestring | null

family_namestring | null

display_namestring | null

preferred_languagestring | null

localestring | null

timezonestring | null

active_membershipallOf | nullrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/accept-invite?token=your_verification_token_here" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/accept-invite?token=your_verification_token_here";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/accept-invite?token=your_verification_token_here";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/accept-invite?token=your_verification_token_here",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/accept-invite?token=your_verification_token_here",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/accept-invite?token=your_verification_token_here", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/accept-invite?token=your_verification_token_here", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/accept-invite?token=your_verification_token_here", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/accept-invite?token=your_verification_token_here", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/accept-invite?token=your_verification_token_here")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/accept-invite?token=your_verification_token_here", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/accept-invite?token=your_verification_token_here");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/check-email

Check if an email exists and which login methods are available. Used for multi-step login flows to determine next steps. Send client_id in the JSON request body on every call; hostname-only client resolution is no longer supported for this endpoint. More

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Bodyapplication/json

client_idstringrequired

Unique identifier for a client application.

csrf_tokenstring

emailstring · emailrequired

Responses

200application/json

schemaobject

statusrequired

preferredarrayrequired

itemrequired

availablearrayrequired

itemrequired

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/check-email" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"client_id":"cid123","email":"test@examples.com"}'

const payload = {"client_id":"cid123","email":"test@examples.com"};
const url = "${BASE_URL}/auth/check-email";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"client_id":"cid123","email":"test@examples.com"};
const url = "${BASE_URL}/auth/check-email";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"client_id":"cid123","email":"test@examples.com"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/check-email",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"client_id":"cid123","email":"test@examples.com"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/check-email",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"client_id":"cid123","email":"test@examples.com"};
const { body } = await request("${BASE_URL}/auth/check-email", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"client_id":"cid123","email":"test@examples.com"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/check-email", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"client_id":"cid123","email":"test@examples.com"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/check-email", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"client_id":"cid123","email":"test@examples.com"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/check-email", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"client_id":"cid123","email":"test@examples.com"}
uri = URI("${BASE_URL}/auth/check-email")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"client_id":"cid123","email":"test@examples.com"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/check-email", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/check-email");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"client_id\":\"cid123\",\"email\":\"test@examples.com\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/csrf-session

Initialize a CSRF session cookie. Sets an HttpOnly, Secure, SameSite=Strict cookie used for CSRF token generation. Returns a JavaScript snippet for auto-fetching the token. More

Responses

200application/javascript

A small JavaScript snippet to fetch the CSRF token with the CSRF session cookie we just set.

schemastring

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/csrf-session" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/csrf-session";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/csrf-session";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/csrf-session",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/csrf-session",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/csrf-session", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/csrf-session", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/csrf-session", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/csrf-session", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/csrf-session")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/csrf-session", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/csrf-session");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/csrf-token

Generate a CSRF token for the current session. Used to protect against Cross-Site Request Forgery attacks. Send in the X-CSRF-Token header of state-changing requests. More

Responses

200application/json

CSRF token generated successfully

schema

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/csrf-token" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/csrf-token";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/csrf-token";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/csrf-token",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/csrf-token",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/csrf-token", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/csrf-token", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/csrf-token", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/csrf-token", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/csrf-token")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/csrf-token", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/csrf-token");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/login-methods

Return currently available login methods for a client. Includes OAuth provider authorize/callback endpoints and password/magic-link submit URLs. Send client_id in the JSON request body; this endpoint no longer resolves the client from hostname alone. More

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Bodyapplication/json

client_idstringrequired

Unique identifier for a client application.

Responses

200application/json

schemaobject

oauth_googleobject

login_methodrequired

authorize_urlstring · urirequired

callback_urlstring · urirequired

oauth_githubobject

login_methodrequired

authorize_urlstring · urirequired

callback_urlstring · urirequired

oauth_facebookobject

login_methodrequired

authorize_urlstring · urirequired

callback_urlstring · urirequired

oauth_appleobject

login_methodrequired

authorize_urlstring · urirequired

callback_urlstring · urirequired

oauth_microsoftobject

login_methodrequired

authorize_urlstring · urirequired

callback_urlstring · urirequired

passwordobject

login_methodrequired

submit_urlstring · urirequired

magic_linkobject

login_methodrequired

submit_urlstring · urirequired

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/login-methods" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"client_id":"your_client_id_here"}'

const payload = {"client_id":"your_client_id_here"};
const url = "${BASE_URL}/auth/login-methods";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"client_id":"your_client_id_here"};
const url = "${BASE_URL}/auth/login-methods";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"client_id":"your_client_id_here"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/login-methods",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"client_id":"your_client_id_here"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/login-methods",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"client_id":"your_client_id_here"};
const { body } = await request("${BASE_URL}/auth/login-methods", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"client_id":"your_client_id_here"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/login-methods", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"client_id":"your_client_id_here"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/login-methods", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"client_id":"your_client_id_here"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/login-methods", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"client_id":"your_client_id_here"}
uri = URI("${BASE_URL}/auth/login-methods")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"client_id":"your_client_id_here"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/login-methods", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/login-methods");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"client_id\":\"your_client_id_here\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/me

Get the current authenticated user’s profile. Returns user info, email credentials, account memberships, and the active membership selected by the authenticated token’s acc claim. More

Responses

200application/jsonSessionProfile

schemaSessionProfile

A user's session profile including their credentials, memberships, identity, and currently active membership context.

idstringrequired

Unique identifier for a user.

application_idstringrequired

Unique identifier for an application.

statusrequired

credentialsarrayrequired

itemEmailCredentialrequired

Associates an email address with a user for authentication. Used to look up users during login flows and verify email ownership.

idstringrequired

user_idstringrequired

Unique identifier for a user.

emailEmailAddress | nullEmailAddress

A valid, normalized email address.

hashed_emailstring | null

email_verified_atstring | null

membershipsarrayrequired

itemallOfrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

identityUserIdentity | nullUserIdentityrequired

Personal profile information for a user including name, avatar, and locale preferences. Stored separately from authentication data for GDPR compliance.

idstringrequired

Unique identifier for a user.

avatar_urlstring · uri | null

external_idstring | null

given_namestring | null

family_namestring | null

display_namestring | null

preferred_languagestring | null

localestring | null

timezonestring | null

active_membershipallOf | nullrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

idstringrequired

Unique identifier for a membership.

account_idstringrequired

Unique identifier for an account.

user_idstringrequired

Unique identifier for a user.

rolerequired

Option 2object

accountAccountrequired

Nested fields truncated. Expand to continue inline, or use the model link.

Represents a billing container with domains and billing settings. Accounts form a hierarchy with applications where types alternate.

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/me" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/me";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/me";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/me",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/me",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/me", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/me", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/me", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/me", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/me")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/me", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/me");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/refresh

Exchange a refresh token for a new access token and refresh token.

You can use this endpoint in two ways:

JSON body (direct API calls)

Send refresh_token in the JSON request body.
This is the usual choice for server-side code or scripts that call the HTTP API directly.

Cookie-based session (browser or SDK clients)

Send the request with credentials/cookies.
If refresh_token is not present in the JSON body, the server will try to read the refresh token from the configured refresh-token cookie (the default cookie name is refresh_token) by deriving the client from the refresh token’s stored JWT cid claim.

Cookie-based refresh only works when the browser can send cookies to the auth service. In practice this means:

The auth service is exposed on the same domain as your application, or
Your application calls the auth service through a reverse proxy so that the browser sees a matching domain.

When the request uses cookies and the refresh succeeds, the server also updates the HTTP-only cookies with the new tokens.

Refresh preserves the existing subject and authorization claims. The token timestamps are renewed, and the iss claim is recalculated from the current application authority hostname. This endpoint derives the client from the refresh token and does not accept client_id.

Bodyapplication/json

refresh_tokenstring

Optional. If omitted, the server will try to read the refresh token from a cookie (when cookies are available).

Responses

200application/jsonSessionTokens

schemaSessionTokens

The set of tokens issued to a client upon successful authentication or token refresh

access_tokenAccessTokenrequired

A short-lived JWT access token signed by the authentication service

refresh_tokenRefreshTokenrequired

An opaque long-lived refresh token used to obtain new access tokens. Can be revoked.

token_typeTokenTyperequired

Description of how the access token should be used

expires_inTimestampInSecondsrequired

A Unix timestamp in seconds since the epoch

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/refresh" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"refresh_token":"your_refresh_token_here"}'

const payload = {"refresh_token":"your_refresh_token_here"};
const url = "${BASE_URL}/auth/refresh";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"refresh_token":"your_refresh_token_here"};
const url = "${BASE_URL}/auth/refresh";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"refresh_token":"your_refresh_token_here"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/refresh",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"refresh_token":"your_refresh_token_here"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/refresh",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"refresh_token":"your_refresh_token_here"};
const { body } = await request("${BASE_URL}/auth/refresh", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"refresh_token":"your_refresh_token_here"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/refresh", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"refresh_token":"your_refresh_token_here"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/refresh", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"refresh_token":"your_refresh_token_here"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/refresh", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"refresh_token":"your_refresh_token_here"}
uri = URI("${BASE_URL}/auth/refresh")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"refresh_token":"your_refresh_token_here"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/refresh", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/refresh");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"refresh_token\":\"your_refresh_token_here\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/reset-password

Reset a user’s password using a token from the password reset email. Requires a strong password meeting complexity requirements. The reset token carries the stored client identity, so callers should only send the token and the new password. More

Bodyapplication/json

tokenstringrequired

new_passwordstringrequired

Responses

200application/json

schema

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/reset-password" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"}'

const payload = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"};
const url = "${BASE_URL}/auth/reset-password";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"};
const url = "${BASE_URL}/auth/reset-password";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/reset-password",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/reset-password",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"};
const { body } = await request("${BASE_URL}/auth/reset-password", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/reset-password", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/reset-password", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/reset-password", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"}
uri = URI("${BASE_URL}/auth/reset-password")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/reset-password", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/reset-password");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"token\":\"your_reset_token_here\",\"new_password\":\"YourNewP@ssw0rd!\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/send-email-verification

Send an email verification link to confirm ownership of an email address. Requires authentication. More

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Bodyapplication/json

email_idstringrequired

Responses

204

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/send-email-verification" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"email_id":"string"}'

const payload = {"email_id":"string"};
const url = "${BASE_URL}/auth/send-email-verification";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"email_id":"string"};
const url = "${BASE_URL}/auth/send-email-verification";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"email_id":"string"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/send-email-verification",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"email_id":"string"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/send-email-verification",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"email_id":"string"};
const { body } = await request("${BASE_URL}/auth/send-email-verification", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"email_id":"string"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/send-email-verification", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"email_id":"string"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/send-email-verification", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"email_id":"string"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/send-email-verification", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"email_id":"string"}
uri = URI("${BASE_URL}/auth/send-email-verification")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"email_id":"string"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/send-email-verification", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/send-email-verification");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"email_id\":\"string\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/send-magic-link

Send a one-time passwordless login link to the user’s email. The link authenticates the user when clicked. Send client_id in the JSON request body; this endpoint no longer infers the client from the request hostname. More

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Bodyapplication/json

client_idstringrequired

Unique identifier for a client application.

csrf_tokenstring

emailEmailAddressrequired

A valid, normalized email address.

Responses

204

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/send-magic-link" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"client_id":"your_client_id_here","email":"test@example.com"}'

const payload = {"client_id":"your_client_id_here","email":"test@example.com"};
const url = "${BASE_URL}/auth/send-magic-link";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"client_id":"your_client_id_here","email":"test@example.com"};
const url = "${BASE_URL}/auth/send-magic-link";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"client_id":"your_client_id_here","email":"test@example.com"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/send-magic-link",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"client_id":"your_client_id_here","email":"test@example.com"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/send-magic-link",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"client_id":"your_client_id_here","email":"test@example.com"};
const { body } = await request("${BASE_URL}/auth/send-magic-link", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"client_id":"your_client_id_here","email":"test@example.com"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/send-magic-link", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"client_id":"your_client_id_here","email":"test@example.com"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/send-magic-link", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"client_id":"your_client_id_here","email":"test@example.com"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/send-magic-link", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"client_id":"your_client_id_here","email":"test@example.com"}
uri = URI("${BASE_URL}/auth/send-magic-link")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"client_id":"your_client_id_here","email":"test@example.com"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/send-magic-link", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/send-magic-link");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"client_id\":\"your_client_id_here\",\"email\":\"test@example.com\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/send-password-reset

Send a password reset link to the user’s email. The link allows setting a new password when clicked. Send client_id in the JSON request body; this endpoint no longer infers the client from the request hostname. More

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Bodyapplication/json

client_idstringrequired

Unique identifier for a client application.

csrf_tokenstring

emailEmailAddressrequired

A valid, normalized email address.

Responses

204

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/send-password-reset" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"client_id":"your_client_id_here","email":"test@example.com"}'

const payload = {"client_id":"your_client_id_here","email":"test@example.com"};
const url = "${BASE_URL}/auth/send-password-reset";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"client_id":"your_client_id_here","email":"test@example.com"};
const url = "${BASE_URL}/auth/send-password-reset";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"client_id":"your_client_id_here","email":"test@example.com"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/send-password-reset",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"client_id":"your_client_id_here","email":"test@example.com"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/send-password-reset",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"client_id":"your_client_id_here","email":"test@example.com"};
const { body } = await request("${BASE_URL}/auth/send-password-reset", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"client_id":"your_client_id_here","email":"test@example.com"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/send-password-reset", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"client_id":"your_client_id_here","email":"test@example.com"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/send-password-reset", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"client_id":"your_client_id_here","email":"test@example.com"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/send-password-reset", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"client_id":"your_client_id_here","email":"test@example.com"}
uri = URI("${BASE_URL}/auth/send-password-reset")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"client_id":"your_client_id_here","email":"test@example.com"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/send-password-reset", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/send-password-reset");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"client_id\":\"your_client_id_here\",\"email\":\"test@example.com\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/sign-in

Authenticate a user with email and password. Returns access tokens, refresh tokens, and the user’s profile on success. Send client_id in the JSON request body; this endpoint no longer infers the client from the request hostname. More

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Bodyapplication/json

client_idstringrequired

Unique identifier for a client application.

emailstringrequired

passwordstringrequired

csrf_tokenstring

Responses

200application/jsonAuthenticationResult

The complete result of a successful authentication operation, including tokens and user profile context

tokensSessionTokensrequired

The set of tokens issued to a client upon successful authentication or token refresh

access_tokenAccessTokenrequired

A short-lived JWT access token signed by the authentication service

refresh_tokenRefreshTokenrequired

An opaque long-lived refresh token used to obtain new access tokens. Can be revoked.

token_typeTokenTyperequired

Description of how the access token should be used

expires_inTimestampInSecondsrequired

A Unix timestamp in seconds since the epoch

profileSessionProfilerequired

A user's session profile including their credentials, memberships, identity, and currently active membership context.

idstringrequired

Unique identifier for a user.

application_idstringrequired

Unique identifier for an application.

statusrequired

credentialsarrayrequired

itemEmailCredentialrequired

Nested fields truncated. Expand to continue inline, or use the model link.

Associates an email address with a user for authentication. Used to look up users during login flows and verify email ownership.

membershipsarrayrequired

itemallOfrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

identityUserIdentity | nullUserIdentityrequired

Personal profile information for a user including name, avatar, and locale preferences. Stored separately from authentication data for GDPR compliance.

idstringrequired

Unique identifier for a user.

avatar_urlstring · uri | null

external_idstring | null

given_namestring | null

family_namestring | null

display_namestring | null

preferred_languagestring | null

localestring | null

timezonestring | null

active_membershipallOf | nullrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/sign-in" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}'

const payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const url = "${BASE_URL}/auth/sign-in";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const url = "${BASE_URL}/auth/sign-in";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/sign-in",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/sign-in",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const { body } = await request("${BASE_URL}/auth/sign-in", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/sign-in", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/sign-in", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/sign-in", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}
uri = URI("${BASE_URL}/auth/sign-in")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/sign-in", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/sign-in");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"client_id\":\"your_client_id_here\",\"email\":\"test@example.com\",\"password\":\"your_password_here\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/sign-in-with-token

Sign in a user using a one-time login token (e.g., from magic links, invite emails, or OTP flows). This endpoint is designed for direct navigation via emailed links, hence the GET method and query parameter.

The token is single-use, short-lived, and invalidated upon successful consumption. For security, ensure links are delivered over encrypted channels and include CSRF protections in redirect flows if applicable.

Unlike credential-based sign-in (POST /auth/sign-in), this endpoint does not require authentication headers and returns an AuthenticationResult on success, enabling immediate session establishment.

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Responses

200application/jsonAuthenticationResult

The complete result of a successful authentication operation, including tokens and user profile context

tokensSessionTokensrequired

The set of tokens issued to a client upon successful authentication or token refresh

access_tokenAccessTokenrequired

A short-lived JWT access token signed by the authentication service

refresh_tokenRefreshTokenrequired

An opaque long-lived refresh token used to obtain new access tokens. Can be revoked.

token_typeTokenTyperequired

Description of how the access token should be used

expires_inTimestampInSecondsrequired

A Unix timestamp in seconds since the epoch

profileSessionProfilerequired

A user's session profile including their credentials, memberships, identity, and currently active membership context.

idstringrequired

Unique identifier for a user.

application_idstringrequired

Unique identifier for an application.

statusrequired

credentialsarrayrequired

itemEmailCredentialrequired

Nested fields truncated. Expand to continue inline, or use the model link.

Associates an email address with a user for authentication. Used to look up users during login flows and verify email ownership.

membershipsarrayrequired

itemallOfrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

identityUserIdentity | nullUserIdentityrequired

Personal profile information for a user including name, avatar, and locale preferences. Stored separately from authentication data for GDPR compliance.

idstringrequired

Unique identifier for a user.

avatar_urlstring · uri | null

external_idstring | null

given_namestring | null

family_namestring | null

display_namestring | null

preferred_languagestring | null

localestring | null

timezonestring | null

active_membershipallOf | nullrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/sign-in-with-token?token=string" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/sign-in-with-token?token=string";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/sign-in-with-token?token=string";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/sign-in-with-token?token=string",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/sign-in-with-token?token=string",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/sign-in-with-token?token=string", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/sign-in-with-token?token=string", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/sign-in-with-token?token=string", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/sign-in-with-token?token=string", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/sign-in-with-token?token=string")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/sign-in-with-token?token=string", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/sign-in-with-token?token=string");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/sign-up

Register a new user with email and password. Creates a user, account, and returns authentication tokens on success. Send client_id in the JSON request body; this endpoint no longer infers the client from the request hostname. More

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Bodyapplication/json

client_idstringrequired

Unique identifier for a client application.

csrf_tokenstring

emailEmailAddressrequired

A valid, normalized email address.

passwordstringrequired

preferred_languagestring

localestring

timezonestring

Responses

200application/jsonAuthenticationResult

The complete result of a successful authentication operation, including tokens and user profile context

tokensSessionTokensrequired

The set of tokens issued to a client upon successful authentication or token refresh

access_tokenAccessTokenrequired

A short-lived JWT access token signed by the authentication service

refresh_tokenRefreshTokenrequired

An opaque long-lived refresh token used to obtain new access tokens. Can be revoked.

token_typeTokenTyperequired

Description of how the access token should be used

expires_inTimestampInSecondsrequired

A Unix timestamp in seconds since the epoch

profileSessionProfilerequired

A user's session profile including their credentials, memberships, identity, and currently active membership context.

idstringrequired

Unique identifier for a user.

application_idstringrequired

Unique identifier for an application.

statusrequired

credentialsarrayrequired

itemEmailCredentialrequired

Nested fields truncated. Expand to continue inline, or use the model link.

Associates an email address with a user for authentication. Used to look up users during login flows and verify email ownership.

membershipsarrayrequired

itemallOfrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

identityUserIdentity | nullUserIdentityrequired

Personal profile information for a user including name, avatar, and locale preferences. Stored separately from authentication data for GDPR compliance.

idstringrequired

Unique identifier for a user.

avatar_urlstring · uri | null

external_idstring | null

given_namestring | null

family_namestring | null

display_namestring | null

preferred_languagestring | null

localestring | null

timezonestring | null

active_membershipallOf | nullrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/sign-up" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}'

const payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const url = "${BASE_URL}/auth/sign-up";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const url = "${BASE_URL}/auth/sign-up";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/sign-up",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/sign-up",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
const { body } = await request("${BASE_URL}/auth/sign-up", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/sign-up", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/sign-up", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/sign-up", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"}
uri = URI("${BASE_URL}/auth/sign-up")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"client_id":"your_client_id_here","email":"test@example.com","password":"your_password_here"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/sign-up", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/sign-up");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"client_id\":\"your_client_id_here\",\"email\":\"test@example.com\",\"password\":\"your_password_here\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/auth/switch-accounts

Switch the authenticated user session into another account they belong to. Returns a fresh auth session response with tokens and profile, where the active membership matches the requested account_id. This endpoint derives the client from the authenticated session and does not accept client_id. When called with cookies, it requires a CSRF token and allowed Origin. More

Headers

Originstring · urirequired

Origin of the caller (scheme://host[:port])

Bodyapplication/json

account_idstringrequired

Unique identifier for an account.

csrf_tokenstring

Responses

200application/jsonAuthenticationResult

The complete result of a successful authentication operation, including tokens and user profile context

tokensSessionTokensrequired

The set of tokens issued to a client upon successful authentication or token refresh

access_tokenAccessTokenrequired

A short-lived JWT access token signed by the authentication service

refresh_tokenRefreshTokenrequired

An opaque long-lived refresh token used to obtain new access tokens. Can be revoked.

token_typeTokenTyperequired

Description of how the access token should be used

expires_inTimestampInSecondsrequired

A Unix timestamp in seconds since the epoch

profileSessionProfilerequired

A user's session profile including their credentials, memberships, identity, and currently active membership context.

idstringrequired

Unique identifier for a user.

application_idstringrequired

Unique identifier for an application.

statusrequired

credentialsarrayrequired

itemEmailCredentialrequired

Nested fields truncated. Expand to continue inline, or use the model link.

Associates an email address with a user for authentication. Used to look up users during login flows and verify email ownership.

membershipsarrayrequired

itemallOfrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

identityUserIdentity | nullUserIdentityrequired

Personal profile information for a user including name, avatar, and locale preferences. Stored separately from authentication data for GDPR compliance.

idstringrequired

Unique identifier for a user.

avatar_urlstring · uri | null

external_idstring | null

given_namestring | null

family_namestring | null

display_namestring | null

preferred_languagestring | null

localestring | null

timezonestring | null

active_membershipallOf | nullrequired

Variant

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

MembershipMembership

Nested fields truncated. Expand to continue inline, or use the model link.

Links a user to an account with a specific role (owner, member, or viewer). Users can have memberships in multiple accounts.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/auth/switch-accounts" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"account_id":"acc123","csrf_token":"csrf_token_here"}'

const payload = {"account_id":"acc123","csrf_token":"csrf_token_here"};
const url = "${BASE_URL}/auth/switch-accounts";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"account_id":"acc123","csrf_token":"csrf_token_here"};
const url = "${BASE_URL}/auth/switch-accounts";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"account_id":"acc123","csrf_token":"csrf_token_here"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/auth/switch-accounts",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"account_id":"acc123","csrf_token":"csrf_token_here"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/auth/switch-accounts",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"account_id":"acc123","csrf_token":"csrf_token_here"};
const { body } = await request("${BASE_URL}/auth/switch-accounts", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"account_id":"acc123","csrf_token":"csrf_token_here"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/switch-accounts", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"account_id":"acc123","csrf_token":"csrf_token_here"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/auth/switch-accounts", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"account_id":"acc123","csrf_token":"csrf_token_here"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/auth/switch-accounts", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"account_id":"acc123","csrf_token":"csrf_token_here"}
uri = URI("${BASE_URL}/auth/switch-accounts")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"account_id":"acc123","csrf_token":"csrf_token_here"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/auth/switch-accounts", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/auth/switch-accounts");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"account_id\":\"acc123\",\"csrf_token\":\"csrf_token_here\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/verify

Verify a user’s email address using a verification token sent via email. Marks the email as verified on success. More

Responses

204

No Content

400application/problem+jsonValidationProblemDetails

Bad Request

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/verify?token=string" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/verify?token=string";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/verify?token=string";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/verify?token=string",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/verify?token=string",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/verify?token=string", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/verify?token=string", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/verify?token=string", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/verify?token=string", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/verify?token=string")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/verify?token=string", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/verify?token=string");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/waitlists

List the current user’s waitlist signups in the token account context. More

Responses

200application/json

schemaobject

dataarrayrequired

itemobjectrequired

idstringrequired

Unique identifier for a waitlist row.

application_idstringrequired

Unique identifier for an application.

user_idstringrequired

Unique identifier for a user.

account_idstringrequired

Unique identifier for an account.

feature_keystringrequired

Feature key for the waitlist row.

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current page

nextstring

URL of the next page

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/waitlists" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/waitlists";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/waitlists";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/waitlists",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/waitlists",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/waitlists", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/waitlists", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/waitlists", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/waitlists", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/waitlists")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/waitlists", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/waitlists");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE/auth/waitlists/{feature_key}

Idempotently remove the current user from a waitlist feature in the token account context. More

Responses

200application/json

schemaobject

dataobjectrequired

feature_keystringrequired

Feature key for the waitlist row.

signed_upbooleanrequired

waitlist_idstring | nullrequired

Unique identifier for a waitlist row.

linksobjectrequired

selfstringrequired

URL of the current resource

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X DELETE \\
  "${BASE_URL}/auth/waitlists/gmail_enabled" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/waitlists/gmail_enabled";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/waitlists/gmail_enabled";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "delete",
  url: "${BASE_URL}/auth/waitlists/gmail_enabled",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "delete",
  url: "${BASE_URL}/auth/waitlists/gmail_enabled",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/waitlists/gmail_enabled", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "DELETE", \
    "${BASE_URL}/auth/waitlists/gmail_enabled", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "DELETE", \
        "${BASE_URL}/auth/waitlists/gmail_enabled", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("DELETE", "${BASE_URL}/auth/waitlists/gmail_enabled", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/waitlists/gmail_enabled")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("DELETE", "${BASE_URL}/auth/waitlists/gmail_enabled", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "${BASE_URL}/auth/waitlists/gmail_enabled");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/auth/waitlists/{feature_key}

Check whether the current user is signed up for a waitlist feature in the token account context. More

Responses

200application/json

schemaobject

dataobjectrequired

feature_keystringrequired

Feature key for the waitlist row.

signed_upbooleanrequired

waitlist_idstring | nullrequired

Unique identifier for a waitlist row.

linksobjectrequired

selfstringrequired

URL of the current resource

defaultapplication/problem+jsonProblemDetails

HTTP Error

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/auth/waitlists/gmail_enabled" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/auth/waitlists/gmail_enabled";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/auth/waitlists/gmail_enabled";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/auth/waitlists/gmail_enabled",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/auth/waitlists/gmail_enabled",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/auth/waitlists/gmail_enabled", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/auth/waitlists/gmail_enabled", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/auth/waitlists/gmail_enabled", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/auth/waitlists/gmail_enabled", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/auth/waitlists/gmail_enabled")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/auth/waitlists/gmail_enabled", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/auth/waitlists/gmail_enabled");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PUT/auth/waitlists/{feature_key}

Idempotently sign up the current user for a waitlist feature in the token account context. More

Responses

200application/json

schemaobject

dataobjectrequired

feature_keystringrequired

Feature key for the waitlist row.

signed_upbooleanrequired

waitlist_idstring | nullrequired

Unique identifier for a waitlist row.

linksobjectrequired

selfstringrequired

URL of the current resource

defaultapplication/problem+jsonProblemDetails

HTTP Error