The WorkOS API enables adding Enterprise Ready features to your application. This REST API provides programmatic access to AuthKit (user management), Single Sign-On, Directory Sync, and Audit Log resources.

Sign in to see code examples customized with your API keys and data.

https://api.workos.com

WorkOS offers native SDKs in several popular programming languages. Choose one language below to see our API Reference in your application’s language.

npm install @workos-inc/node

You can test the API directly with cURL, or use the Postman collection for convenience.

WorkOS authenticates your API requests using your account’s API keys. API requests made without authentication or using an incorrect key will return a 401 error. Requests using a valid key but with insufficient permissions will return a 403 error. All API requests must be made over HTTPS. Any requests made over plain HTTP will fail.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

You can view and manage your API keys in the WorkOS Dashboard.

API keys can perform any API request to WorkOS. They should be kept secure and private! Be sure to prevent API keys from being made publicly accessible, such as in client-side code, GitHub, unsecured S3 buckets, and so forth. API keys are prefixed with sk_.

Your Staging Environment comes with an API key already generated for you. Staging API keys may be viewed as often as they are needed and will appear inline throughout our documentation in code examples if you are logged in to your WorkOS account. API requests will be scoped to the provided key’s Environment.

Once you unlock Production access you will need to generate an API Key for it. Production API keys may only be viewed once and will need to be saved in a secure location upon creation of them.

WorkOS uses standard HTTP response codes to indicate the success or failure of your API requests.

200

Successful request.

400

The request was not acceptable. Check that the parameters were correct.

401

The API key used was invalid.

403

The API key used did not have the correct permissions.

404

The resource was not found.

422

Validation failed for the request. Check that the parameters were correct.

429

Too many requests. Refer to the Rate Limits section.

5xx

Indicates an error with WorkOS servers.

Many top-level resources have support for bulk fetches via list API methods. For instance, you can list connections, list directory users, and list directory groups. These list API methods share a common structure, taking at least these four parameters: limit, order, after, and before.

WorkOS utilizes pagination via the after and before parameters. Both parameters take an existing object ID value and return objects in either descending or ascending order by creation time.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

let list = await workos.sso.listConnections({ limit: 100, order: 'desc' });
let connections = list.data;
let after = list.listMetadata.after;

while (after) {
  list = await workos.sso.listConnections({
    limit: 100,
    after: after,
    order: 'desc',
  });
  connections = connections.concat(list.data);
  after = list.listMetadata.after;
}

WorkOS APIs are rate limited to ensure that they are fast for everyone. If you find yourself getting 429 errors, double check your integration to make sure you aren’t making unnecessary requests.

This rate limits applies to all environments, staging and production. Exceptions to the general rate limit are listed below.

Rate limiting for AuthKit APIs are enforced on a per environment basis.

The Admin Portal is a standalone application where your users can configure and manage WorkOS resources such as Connections and Directories that are scoped to their Organization.

A Portal Link is a temporary endpoint to initiate an Admin Portal session. It expires five minutes after issuance.

https://setup.workos.com?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

Generate a Portal Link scoped to an Organization.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const { link } = await workos.portal.generateLink({
  organization: 'org_01EHZNVPK3SFK441A1RGBFSHRT',
  intent: 'sso',
});

Icons for third-party providers are available through the WorkOS CDN. These icons cover identity providers, Directory Sync, and domain verification services used within the Admin Portal.

Get a list of all of existing provider icons.

curl https://cdn.workos.com/provider-icons.json 

To use an icon in your project, you can reference the CDN link directly. You can alternate between light and dark mode icons by changing the path in the URL or using CSS media queries.

<picture>
  <source
    srcset="https://cdn.workos.com/provider-icons/dark/okta.svg"
    media="(prefers-color-scheme: dark)"
  />
  <img
    src="https://cdn.workos.com/provider-icons/light/okta.svg"
    alt="Okta icon"
  />
</picture>

You can change the icons to grayscale by adding the filter CSS property.

img {
  filter: grayscale(100%);
}

Audit Logs are a collection of events that contain information relevant to notable actions taken by users in your application. Every event in the collection contains details regarding what kind of action was taken (action), who performed the action (actor), what resources were affected by the action (targets), and additional details of when and where the action took place.

Create an Audit Log Event.

This API supports idempotency which guarantees that performing the same operation multiple times will have the same result as if the operation were performed only once. This is handy in situations where you may need to retry a request due to a failure or prevent accidental duplicate requests from creating more than one resource.

To achieve idempotency, you can add Idempotency-Key request header to a Create Event request with a unique string as the value. Each subsequent request matching this unique string will return the same response. We suggest using v4 UUIDs for idempotency keys to avoid collisions.

Idempotency keys expire after 24 hours. The API will generate a new response if you submit a request with an expired key.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

await workos.auditLogs.createEvent(
  'org_01EHWNCE74X7JSDV0X3SZ3KJNY',
  {
    action: 'user.signed_in',
    occurredAt: new Date(),
    version: 1,
    actor: {
      type: 'user',
      id: 'user_TF4C5938',
      name: 'Jon Smith',
      metadata: {
        role: 'admin',
      },
    },
    targets: [
      {
        type: 'user',
        id: 'user_98432YHF',
        name: 'Jon Smith',
      },
      {
        type: 'team',
        id: 'team_J8YASKA2',
        metadata: {
          owner: 'user_01GBTCQ2',
        },
      },
    ],
    context: {
      location: '1.1.1.1',
      userAgent: 'Chrome/104.0.0.0',
    },
    metadata: {
      extra: 'data',
    },
  },
  {
    idempotencyKey: '884793cd-bef4-46cf-8790-ed49257a09c6',
  },
);

An object representing an Audit Log Schema.

const auditLogSchema = {
  object: 'audit_log_schema',
  version: 1,
  targets: [{ type: 'user', metadata: {} }],
  actor: { metadata: {} },
  metadata: {},
  createdAt: '2024-10-14T15:09:44.537Z',
};

Creates a new Audit Log schema used to validate the payload of incoming Audit Log Events. If the action does not exist, it will also be created.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const schema = await workos.auditLogs.createSchema({
  action: 'user.viewed_invoice',
  actor: {
    metadata: {
      role: 'string',
    },
  },
  targets: [
    {
      type: 'user',
      metadata: {
        status: 'string',
      },
    },
  ],
  metadata: {
    invoice_id: 'string',
  },
});

Get a list of all schemas for the Audit Logs action identified by :name.

curl https://api.workos.com/audit_logs/actions/user.viewed_invoice/schemas \
  --header "Authorization: Bearer sk_example_123456789"

Get a list of all Audit Log actions in the current environment.

curl https://api.workos.com/audit_logs/actions \
  --header "Authorization: Bearer sk_example_123456789"

An object representing an Audit Log Export.

const auditLogExport = {
  object: 'audit_log_export',
  id: 'audit_log_export_01GBZK5MP7TD1YCFQHFR22180V',
  state: 'ready',
  url: 'https://exports.audit-logs.com/audit-log-exports/export.csv',
  created_at: '2022-09-02T17:14:57.094Z',
  updated_at: '2022-09-02T17:14:57.094Z',
};

Create an Audit Log Export.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const auditLogExport = await workos.auditLogs.createExport({
  organizationId: 'org_01EHWNCE74X7JSDV0X3SZ3KJNY',
  rangeStart: new Date('2022-07-02T18:09:06.996Z'),
  rangeEnd: new Date('2022-09-02T18:09:06.996Z'),
  actions: ['user.signed_in'],
  actors: ['Jon Smith'],
  targets: ['team'],
});

Get an Audit Log Export.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const auditLogExport = await workos.auditLogs.getExport(
  'audit_log_export_01GBZK5MP7TD1YCFQHFR22180V',
);

Get the configured event retention period for the given Organization.

curl https://api.workos.com/organizations/org_01EHZNVPK3SFK441A1RGBFSHRT/audit_logs_retention \
  --header "Authorization: Bearer sk_example_123456789"

Set the event retention period for the given Organization.

curl --request PUT \
  --url https://api.workos.com/organizations/org_01EHZNVPK3SFK441A1RGBFSHRT/audit_logs_retention \
  --header "Authorization: Bearer sk_example_123456789" \
  --header "Content-Type: application/json" \
  -d '{ "retention_period_in_days": 30 }'

The Audit Log Configuration endpoint provides a single view of an organization’s audit logging setup. It includes retention settings (how long audit logs are stored), the audit log state (active, inactive, or disabled), and – if configured – the audit log stream, which sends events to external destinations like Splunk, Datadog, S3, Google Cloud Storage, or a custom HTTPS endpoint.

The log_stream field is optional and only appears if the organization has a stream configured. If no stream is set up, the response includes only the audit log retention and state information.

curl https://api.workos.com/organizations/org_01EHZNVPK3SFK441A1RGBFSHRT/audit_log_configuration \
  --header "Authorization: Bearer sk_example_123456789"

AuthKit is a user management platform that provides a set of user authentication and organization security features designed to provide a fast, scalable integration while handling all of the user management complexity that comes with advanced B2B customer needs.

To automatically respond to AuthKit activities, like authentication and changes related to the users, use the corresponding events.

Represents a user identity in your application. A user can sign up in your application directly with a method like password, or they can be JIT-provisioned through an organization’s SSO connection.

Users may belong to organizations as members.

See the events reference documentation for the user events.

const user = {
  object: 'user',
  id: 'user_01E4ZCR3C56J083X43JQXF3JK5',
  email: 'marcelina.davis@example.com',
  firstName: 'Marcelina',
  lastName: 'Davis',
  emailVerified: true,
  profilePictureUrl: 'https://workoscdn.com/images/v1/123abc',
  lastSignInAt: '2021-06-25T19:07:33.155Z',
  externalId: 'f1ffa2b2-c20b-4d39-be5c-212726e11222',
  metadata: {
    timezone: 'America/New_York',
  },
  createdAt: '2021-06-25T19:07:33.155Z',
  updatedAt: '2021-06-25T19:07:33.155Z',
};

Get the details of an existing user.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const user = await workos.userManagement.getUser(
  'user_01E4ZCR3C56J083X43JQXF3JK5',
);

Get the details of an existing user by an external identifier.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const user = await workos.userManagement.getUserByExternalId(
  'f1ffa2b2-c20b-4d39-be5c-212726e11222',
);

Get a list of all of your existing users matching the criteria specified.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const users = await workos.userManagement.listUsers();

console.log(users.data);

Create a new user in the current environment.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const user = await workos.userManagement.createUser({
  email: 'marcelina@example.com',
  password: 'i8uv6g34kd490s',
  firstName: 'Marcelina',
  lastName: 'Davis',
});

Updates properties of a user. The omitted properties will be left unchanged.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const user = await workos.userManagement.updateUser({
  userId: 'user_01EHQ7ZGZ2CZVQJGZ5ZJZ1ZJGZ',
  firstName: 'Marcelina',
  lastName: 'Davis',
  emailVerified: true,
  externalId: '2fe01467-f7ea-4dd2-8b79-c2b4f56d0191',
  metadata: {
    timezone: 'America/New_York',
  },
});

Permanently deletes a user in the current environment. It cannot be undone.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

await workos.userManagement.deleteUser('user_01F3GZ5ZGZBZVQGZVHJFVXZJGZ');

Represents User identities obtained from external identity providers.

When a user authenticates using an external provider like Google OAuth, information from that provider will be made available as one of the user’s Identities. You can read more about the process in our identity linking guide.

{
  "idp_id": "4F42ABDE-1E44-4B66-824A-5F733C037A6D",
  "type": "OAuth",
  "provider": "MicrosoftOAuth"
}

Get a list of identities associated with the user. A user can have multiple associated identities after going through identity linking. Currently only OAuth identities are supported. More provider types may be added in the future.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const identities = await workos.userManagement.getUserIdentities(
  'user_01E4ZCR3C56J083X43JQXF3JK5',
);

Authenticate a user with a specified authentication method.

Generates an OAuth 2.0 authorization URL to authenticate a user with AuthKit or SSO.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const authorizationUrl = workos.userManagement.getAuthorizationUrl({
  connectionId: 'conn_01E4ZCR3C56J083X43JQXF3JK5',
  clientId: 'client_123456789',
  redirectUri: 'https://your-app.com/callback',
  state: 'dj1kUXc0dzlXZ1hjUQ==',
});

If you are using AuthKit, set the provider parameter to "authkit", which will generate an authorization URL for your AuthKit domain. AuthKit will take care of detecting the user’s authentication method, such as identifying whether they use Email + Password or Single Sign-On,and direct them to the corresponding login flow.

Otherwise, to generate an authorization URL for a WorkOS SSO connection, you’ll have to specify the user’s connection, organization, or OAuth provider as a parameter. These connection selectors are mutually exclusive, and exactly one must be provided. The generated URL automatically directs the user to their identity provider. Once the user authenticates with their identity provider, WorkOS then issues a redirect to your redirect URI to complete the sign-in flow.

In the OAuth 2.0 protocol, a redirect URI is the location that the user is redirected to once they have successfully authenticated with their identity provider.

When redirecting the user, WorkOS will generate an authorization code and pass it to your redirect URI as a code query parameter, your app will use this code to authenticate the user. Additionally, WorkOS can pass a state parameter back to your application that you may use to encode arbitrary information to restore your application state between the redirects.

https://your-app.com/callback?code=01E2RJ4C05B52KKZ8FSRDAP23J&state=dj1kUXc0dzlXZ1hjUQ==

You can use state to encode parameters like originating URL and query parameters. This is useful in a flow where unauthenticated users are automatically redirected to a login page. After successful sign in, users will be routed to your redirect URI callback route. From there you can extract the originating URL from state and redirect the user to their intended destination.

You’ll need to configure the allowed redirect URIs for your application via the Redirects page in the dashboard. Without a valid redirect URI, your users will be unable to sign in. Make sure that the redirect URI you use as a parameter to get the authorization URL matches one of the redirect URIs you have configured in the dashboard.

Redirect URIs follow stricter requirements in production environments:

• HTTPS protocol is required in production environments
• HTTP and localhost are allowed in staging environments
• The sole exception is the use of http://127.0.0.1 in production environments to support native clients.

Wildcards

WorkOS supports using wildcard characters in Redirect URIs. The * symbol can be used as a wildcard for subdomains; however, it must be used in accordance with the following rules in order to properly function.

• The wildcard must be located in a subdomain within the hostname component. For example, http://*.com will not work.
• The wildcard must be located in the subdomain which is furthest from the root domain. For example, https://sub.*.example.com will not work.
• The URL must not contain more than one wildcard. For example, https://*.*.example.com will not work.
• A wildcard character may be prefixed and/or suffixed with additional valid hostname characters. For example, https://prefix-*-suffix.example.com will work.
• A URL with a valid wildcard will not match a URL more than one subdomain level in place of the wildcard. For example, https://*.example.com will not work with https://sub1.sub2.example.com.
• In production environments, wildcards cannot be used with public suffix domains. For example, https://*.ngrok-free.app will not work.
• The wildcard will match a sequence of letters (A through Z, and a through z ); digits (0 through 9), hyphens (-), and underscores (_). For example, https://user:secret@foo.example.com will not work with https://*.example.com.
• A URL with a wildcard cannot be set as the default redirect URI.

The Proof Key for Code Exchange (PKCE) flow is an extension to the OAuth 2.0 Authorization Code flow. It enables public clients, like native apps or single-page apps, to perform the authorization code flow securely. If you are developing a client that makes API calls in public, you’ll need to use this flow.

In this flow, your client generates a code verifier which is a high-entropy cryptographic random string. A code challenge is derived by hashing the code verifier. Instead of using a client secret, provide the code challenge when getting the authorization URL and the code verifier when authenticating a User.

If there is an issue generating an authorization URL, the API will return the original redirect URI with error and error_description query parameters. If provided, the state value will also be included.

https://your-app.com/callback?error=organization_invalid&error_description=No%20connection%20associated%20with%20organization&state=123456789

Possible error codes and the corresponding descriptions are listed below.

Authenticates a user using AuthKit, OAuth or an organization’s SSO connection.

AuthKit handles all authentication methods, however it is conceptually similar to a social login experience. Like OAuth and SSO, AuthKit returns you a code that you can exchange for an authenticated user. See Integrating with AuthKit.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const { user } = await workos.userManagement.authenticateWithCode({
  clientId: 'client_123456789',
  code: '01E2RJ4C05B52KKZ8FSRDAP23J',
  ipAddress: '192.0.2.1',
  userAgent:
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
});

Authenticates a user with email and password.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const { user } = await workos.userManagement.authenticateWithPassword({
  clientId: 'client_123456789',
  email: 'marcelina@example.com',
  password: 'i8uv6g34kd490s',
  ipAddress: '192.0.2.1',
  userAgent:
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
});

Authenticates a user by verifying the Magic Auth code sent to the user’s email.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const { user } = await workos.userManagement.authenticateWithMagicAuth({
  clientId: 'client_123456789',
  code: '123456',
  email: 'marcelina.davis@example.com',
  ipAddress: '192.0.2.1',
  userAgent:
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
});

Use this endpoint to exchange a refresh token for a new access token. Refresh tokens may be rotated after use, so a replacement refresh token is also provided.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_test_123');

const { refreshToken } =
  await workos.userManagement.authenticateWithRefreshToken({
    clientId: 'client_123456789',
    refreshToken: 'Xw0NsCVXMBf7svAoIoKBmkpEK',
    ipAddress: '192.0.2.1',
    userAgent:
      'Mozilla/5.0 (X11; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0',
  });

Authenticates a user with an unverified email and verifies their email address.

A user with an unverified email address won’t be able to authenticate right away. When they attempt to authenticate with their credentials, the API will return an email verification required error that contains a pending authentication token.

If the email setting for email verification is enabled, WorkOS will automatically send a one-time email verification code to the user’s email address. If the email setting is not enabled, retrieve the email verification code to send the email yourself. Use the pending authentication token from the error and the one-time code the user received to authenticate them and to complete the email verification process.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const { user } = await workos.userManagement.authenticateWithEmailVerification({
  clientId: 'client_123456789',
  code: '123456',
  pendingAuthenticationToken: 'ql1AJgNoLN1tb9llaQ8jyC2dn',
  ipAddress: '192.0.2.1',
  userAgent:
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
});

Authenticates a user enrolled into MFA using time-based one-time password (TOTP).

Users enrolled into MFA are required to enter a TOTP each time they sign in. When they attempt to authenticate with their credentials, the API will return an MFA challenge error that contains a pending authentication token.

To continue with the authentication flow, challenge one of the factors returned by the MFA challenge error response and present a UI to the user to enter the TOTP code. Then, authenticate the user with the TOTP code, the challenge from the factor, and the pending authentication token from the MFA challenge error.

MFA can be enabled via the Authentication page in the WorkOS dashboard.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const { user } = await workos.userManagement.authenticateWithTotp({
  clientId: 'client_123456789',
  code: '123456',
  pendingAuthenticationToken: 'ql1AJgNoLN1tb9llaQ8jyC2dn',
  authenticationChallengeId: 'auth_challenge_01FVYZWQTZQ5VB6BC5MPG2EYC5',
  ipAddress: '192.0.2.1',
  userAgent:
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
});

Authenticates a user into an organization they are a member of.

When a user who is a member of multiple organizations attempts to authenticate with their credentials, the API will return an organization selection error that contains a pending authentication token. To continue with the authentication flow, your application should display the list of organizations for the user to choose.

Use the pending authentication token from the error and the organization the user selected in your UI to complete the authentication.

import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS('sk_example_123456789');

const { user } =
  await workos.userManagement.authenticateWithOrganizationSelection({
    clientId: 'client_123456789',
    organizationId: 'org_01H945H0YD4F97JN9MATX7BYAG',
    pendingAuthenticationToken: 'ql1AJgNoLN1tb9llaQ8jyC2dn',
    ipAddress: '192.0.2.1',
    userAgent:
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
  });