Auth

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.

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. More

Headers

Originstring · urirequired

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

Body application/json

client_idstring

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. More

Headers

Originstring · urirequired

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

Body application/json

client_idstring

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":"cid789"}'

const payload = {"client_id":"cid789"};
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":"cid789"};
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":"cid789"};
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":"cid789"};
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":"cid789"};
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":"cid789"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/login-methods", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"client_id":"cid789"}
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":"cid789"}`))

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":"cid789"}
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":"cid789"};
$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\":\"cid789\"}", 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, and account memberships. 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).

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.

Note that the access token’s contents are not changed by a refresh; it contains the same claims as the previous access token, but with a new expiration time.

Body application/json

refresh_tokenstring

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

client_idstring

Unique identifier for a client application.

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. More

Body application/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 '{"client_id":"your_client_id_here","token":"your_reset_token_here","new_password":"YourNewP@ssw0rd!"}'

const payload = {"client_id":"your_client_id_here","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 = {"client_id":"your_client_id_here","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 = {"client_id":"your_client_id_here","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 = {"client_id":"your_client_id_here","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 = {"client_id":"your_client_id_here","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 = {"client_id":"your_client_id_here","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 = {"client_id":"your_client_id_here","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(`{"client_id":"your_client_id_here","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 = {"client_id":"your_client_id_here","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 = {"client_id":"your_client_id_here","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("{\"client_id\":\"your_client_id_here\",\"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])

Body application/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. More

Headers

Originstring · urirequired

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

Body application/json

client_idstring

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":"cid789","csrf_token":"string","email":"value"}'

const payload = {"client_id":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"}
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":"cid789","csrf_token":"string","email":"value"}
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":"cid789","csrf_token":"string","email":"value"}`))

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":"cid789","csrf_token":"string","email":"value"}
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":"cid789","csrf_token":"string","email":"value"};
$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\":\"cid789\",\"csrf_token\":\"string\",\"email\":\"value\"}", 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. More

Headers

Originstring · urirequired

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

Body application/json

client_idstring

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":"cid789","csrf_token":"string","email":"value"}'

const payload = {"client_id":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"};
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":"cid789","csrf_token":"string","email":"value"}
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":"cid789","csrf_token":"string","email":"value"}
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":"cid789","csrf_token":"string","email":"value"}`))

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":"cid789","csrf_token":"string","email":"value"}
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":"cid789","csrf_token":"string","email":"value"};
$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\":\"cid789\",\"csrf_token\":\"string\",\"email\":\"value\"}", 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. More

Headers

Originstring · urirequired

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

Body application/json

client_idstring

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

Headers

Originstring · urirequired

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

Body application/json

client_idstring

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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"}'

const payload = {"client_id":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"};
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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"};
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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"};
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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"};
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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"};
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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/auth/sign-up", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"client_id":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"}
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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"}`))

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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"}
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":"cid789","csrf_token":"string","email":"value","password":"string","preferred_language":"string","locale":"string","timezone":"string"};
$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\":\"cid789\",\"csrf_token\":\"string\",\"email\":\"value\",\"password\":\"string\",\"preferred_language\":\"string\",\"locale\":\"string\",\"timezone\":\"string\"}", 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