# Backend API errors An index of Clerk Backend API errors. ## Actor tokens ### ActorTokenCannotBeRevoked filename: Status Code: 400 ```json { "errors": [ { "message": "cannot revoke", "long_message": "Actor token cannot be revoked because its status is . Only pending tokens can be revoked.", "code": "actor_token_cannot_be_revoked_code" } ] } ``` ## Agent Tasks ### AgentTaskCannotBeRevoked filename: Status Code: 400 ```json { "errors": [ { "message": "cannot revoke agent task", "long_message": "Agent task cannot be revoked because it has status .", "code": "agent_task_cannot_be_revoked" } ] } ``` ### AgentTaskNotFound filename: Status Code: 404 ```json { "errors": [ { "message": "agent task not found", "long_message": "The requested agent task could not be found.", "code": "agent_task_not_found" } ] } ``` ### AgentTaskSubjectNotFound filename: Status Code: 404 ```json { "errors": [ { "message": "user not found", "long_message": "The user of the agent task no longer exists. Please request a new one.", "code": "agent_task_subject_not_found" } ] } ``` ## Allowlist identifiers ### AllowlistIdentifierNotFound filename: Status Code: 404 ```json { "errors": [ { "message": "Identifier not found", "long_message": "No identifier was found with id ", "code": "resource_not_found" } ] } ``` ### DuplicateAllowlistIdentifier filename: Status Code: 400 ```json { "errors": [ { "message": "duplicate allowlist identifier", "long_message": "the identifier already exists", "code": "duplicate_record" } ] } ``` ## API keys ### APIKeysNotEnabled filename: Status Code: 422 ```json { "errors": [ { "message": "API Keys not enabled", "long_message": "API Keys not enabled", "code": "api_keys_not_enabled" } ] } ``` ## Applications ### AccountlessApplicationNotFound `AccountlessApplicationNotFound` signifies an error when no application with the given claim token could be found filename: Status Code: 404 ```json { "errors": [ { "message": "Application not found", "long_message": "No application was found with the given claim token.", "code": "resource_not_found" } ] } ``` ## Auth ### AuthorizationMissingScopes `AuthorizationMissingScopes` signifies that the authorization is missing required scope(s). Returns a 403 Forbidden error. filename: Status Code: 403 ```json { "errors": [ { "message": "Missing authorization scopes", "long_message": "The authorization is missing required scope(s): .", "code": "authorization_missing_scopes", "meta": { "scopes": [ "" ] } } ] } ``` ### CouldNotAuthenticateRequest filename: Status Code: 401 ```json { "errors": [ { "message": "Could not authenticate request.", "long_message": "Could not authenticate request.", "code": "could_not_authenticate_request" } ] } ``` ### IdentificationExists `IdentificationExists` is returned when the identifier already exists. The code depends on the identifier type: email\_address\_exists, phone\_number\_exists, username\_exists, or external\_account\_exists. filename: Status Code: 400 ```json { "errors": [ { "message": "already exists", "long_message": "This already exists.", "code": "
"
    }
  ]
}
```

### IdentifierFromBlockedCountryCode

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Country code not allowed.",
      "long_message": "Phone number sign ups are not allowed for this country code. Please use a different method.",
      "code": "not_allowed_access",
      "meta": {
        "param_name": "phone_number"
      }
    }
  ]
}
```

### IdentifierNotAllowedAccess

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Access not allowed.",
      "long_message": "  not allowed to access this application.",
      "code": "not_allowed_access",
      "meta": {
        "identifiers": [
          ""
        ]
      }
    }
  ]
}
```

### InvalidAuthentication

`InvalidAuthentication` signifies an error when the request is not authenticated

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "Invalid authentication",
      "long_message": "Unable to authenticate the request, you need to supply an active session",
      "code": "authentication_invalid"
    }
  ]
}
```

### InvalidAuthorization

`InvalidAuthorization` signifies an error when the request is not authorized to perform the given operation

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Unauthorized request",
      "long_message": "You are not authorized to perform this request",
      "code": "authorization_invalid"
    }
  ]
}
```

### InvalidAuthorizationHeaderFormat

`InvalidAuthorizationHeaderFormat` signifies an error when the Authorization header has no proper format.

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "Invalid Authorization header format",
      "long_message": "Invalid Authorization header format. Must be 'Bearer '",
      "code": "authorization_header_format_invalid"
    }
  ]
}
```

### InvalidClerkSecretKey

`InvalidClerkSecretKey` signifies an error when the supplied secret key is invalid

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "The provided Clerk Secret Key is invalid. Make sure that your Clerk Secret Key is correct.",
      "long_message": "The provided Clerk Secret Key is invalid. Make sure that your Clerk Secret Key is correct.",
      "code": "clerk_key_invalid"
    }
  ]
}
```

### InvalidRequestForEnvironment

`InvalidRequestForEnvironment` signifies an error when the incoming request is invalid for given environment(s)

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Invalid request for environment",
      "long_message": "Request only valid for  instances.",
      "code": "request_invalid_for_environment"
    }
  ]
}
```

### RateLimitedCountry

`RateLimitedCountry` is returned when Clerk has temporarily disabled SMS to the
phone number's country.

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Rate limited country code",
      "long_message": "SMS to the country  is temporarily disabled. Please try again later.",
      "code": "unsupported_country_code",
      "meta": {
        "alpha2": "",
        "country_code": ""
      }
    }
  ]
}
```

### RequestInvalidForInstance

`RequestInvalidForInstance` signifies an error when the incoming request is invalid for the instance's settings

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Invalid request for instance",
      "long_message": "This request is not valid for your instance. Modify your instance settings to use this request.",
      "code": "request_invalid_for_instance"
    }
  ]
}
```

### SubaddressRestrictionEmailAlreadyUsed

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "This email address is already in use.",
      "long_message": "This email address is already in use. Creating multiple accounts with the same email address is not allowed.",
      "code": "not_allowed_access"
    }
  ]
}
```

### UnsupportedCountry

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Unsupported country code",
      "long_message": "Phone numbers from this country () are currently not supported. For more information, please contact .",
      "code": "unsupported_country_code",
      "meta": {
        "alpha2": "",
        "country_code": ""
      }
    }
  ]
}
```

## Blocklist identifiers

### BlocklistIdentifierNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Identifier not found",
      "long_message": "No identifier was found with id ",
      "code": "resource_not_found"
    }
  ]
}
```

### DuplicateBlocklistIdentifier

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "duplicate blocklist identifier",
      "long_message": "the identifier  already exists",
      "code": "duplicate_record"
    }
  ]
}
```

## Clients

### ClientNotFound

`ClientNotFound` signifies an error when no client is found with the given ID

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Client not found",
      "long_message": "No client was found with id ",
      "code": "resource_not_found"
    }
  ]
}
```

### ClientNotFoundInRequest

`ClientNotFoundInRequest` signifies an error when no client is found in an incoming request

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "No client found",
      "long_message": "This request is expecting a client and did not find one",
      "code": "client_not_found"
    }
  ]
}
```

## Commerce

### BillingAnnualOnlyPlansNotEnabled

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Annual only plans are not enabled",
      "long_message": "Annual only plans are not enabled, please enable the update in Clerk dashboard.",
      "code": "billing_annual_only_plans_not_enabled"
    }
  ]
}
```

### BillingNotEnabledForOrg

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "access denied",
      "long_message": "The billing feature for organizations is not enabled for this instance. You can enable it at https://dashboard.clerk.com.",
      "code": "billing_not_enabled"
    }
  ]
}
```

### BillingNotEnabledForUser

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "access denied",
      "long_message": "The billing feature for users is not enabled for this instance. You can enable it at https://dashboard.clerk.com.",
      "code": "billing_not_enabled"
    }
  ]
}
```

### CheckoutAlreadyInProgress

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Another checkout is already in progress",
      "long_message": "Another checkout is already in progress",
      "code": "checkout_already_in_progress"
    }
  ]
}
```

### CommerceInsufficientSeats

filename: Status Code: 402
```json
{
  "errors": [
    {
      "message": "Insufficient seats",
      "long_message": "You have reached the seat limit for your current plan.",
      "code": "insufficient_seats",
      "meta": {
        "seats_quantity_to_add": 0,
        "seats_quantity": 0
      }
    }
  ]
}
```

### CommerceSubscriptionItemAlreadyCanceled

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Subscription item already canceled",
      "long_message": "You can't cancel a subscription item that is already canceled",
      "code": "commerce_subscription_item_already_canceled"
    }
  ]
}
```

### CommerceSubscriptionItemCannotBeCanceled

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Subscription item cannot be canceled",
      "long_message": "Subscription item cannot be canceled because ",
      "code": "commerce_subscription_item_cannot_be_canceled"
    }
  ]
}
```

### CommerceSubscriptionItemCannotBeEnded

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Subscription item cannot be ended",
      "long_message": "Subscription item cannot be ended because ",
      "code": "commerce_subscription_item_cannot_be_ended"
    }
  ]
}
```

### CurrencyInvalid

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Invalid currency",
      "long_message": "Currency is not supported",
      "code": "currency_invalid"
    }
  ]
}
```

### DefaultPlanPriceCreationForbidden

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Default plan price creation forbidden",
      "long_message": "Custom prices cannot be created for default plans. Only custom paid plans support additional pricing",
      "code": "default_plan_price_creation_forbidden"
    }
  ]
}
```

### InsufficientCreditBalance

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Insufficient credit balance",
      "long_message": "The decrease amount exceeds the current credit balance",
      "code": "insufficient_credit_balance",
      "meta": {
        "param_name": "amount"
      }
    }
  ]
}
```

### InvalidCreditAction

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid credit action",
      "long_message": "Credit action must be either 'increase' or 'decrease'",
      "code": "invalid_credit_action"
    }
  ]
}
```

### InvalidCreditAmount

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid credit amount",
      "long_message": "Credit amount must be greater than zero",
      "code": "invalid_credit_amount"
    }
  ]
}
```

### MissingPlanID

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Missing plan ID",
      "long_message": "Plan ID is required to perform this operation",
      "code": "missing_plan_id"
    }
  ]
}
```

### OrgMemberLimitExceededForPlanChange

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Organization member limit exceeded",
      "long_message": "Plan change is not allowed because the organization's  occupied seats exceed the limit of  organization memberships.",
      "code": "org_member_limit_exceeded_for_plan_change"
    }
  ]
}
```

### OutOfDatePrice

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Out of date price",
      "long_message": "There was a mismatch in the price transition. The price may have been changed by another request.",
      "code": "out_of_date_price"
    }
  ]
}
```

### PayeeNotActive

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Payee not active",
      "long_message": "Payee is not active",
      "code": "payee_not_active"
    }
  ]
}
```

### PayeeNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Payee not found",
      "long_message": "Payee not found",
      "code": "payee_not_found"
    }
  ]
}
```

### PayeeStatusInvalid

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Payee status is invalid",
      "long_message": "Payee status is invalid",
      "code": "payee_status_invalid"
    }
  ]
}
```

### PayerNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Payer not found",
      "long_message": "Payer not found",
      "code": "payer_not_found"
    }
  ]
}
```

### PaymentAttemptFailedRequiresConfirmation

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Requires confirmation",
      "long_message": "The payment attempt failed because it requires additional confirmation, which is not currently supported. Please use a different payment method.",
      "code": "payment_attempt_failed_requires_confirmation"
    }
  ]
}
```

### PaymentDeclined

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Your card was declined",
      "long_message": "The card was declined.",
      "code": "payment_attempt_failed_card_declined"
    }
  ]
}
```

### PaymentExpiredCard

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Card expired",
      "long_message": "The card has expired.",
      "code": "payment_attempt_failed_card_expired"
    }
  ]
}
```

### PaymentInsufficientFunds

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Insufficient funds",
      "long_message": "The card has insufficient funds.",
      "code": "payment_attempt_failed_card_insufficient_funds"
    }
  ]
}
```

### PaymentMethodRequiredForTransition

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Payment method required",
      "long_message": "A payment method is required to upgrade from a free plan. The subscription payer must add a payment method before this transition can be completed.",
      "code": "payment_method_required_for_transition"
    }
  ]
}
```

### PaymentProcessingError

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Processing error",
      "long_message": "There was a processing error with the payment method.",
      "code": "payment_attempt_failed_processing_error"
    }
  ]
}
```

### PlanAmountInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Paid plan month or annual fee invalid",
      "long_message": "Paid plan month or annual fee invalid",
      "code": "plan_amount_invalid"
    }
  ]
}
```

### PlanAmountTooLarge

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Paid plan monthly base fee exceeds upper limit",
      "long_message": "Paid plan monthly base fee must be less than $999,999.99",
      "code": "plan_amount_exceeds_upper_limit"
    }
  ]
}
```

### PlanDoesNotSupportEmptyOrganizations

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Plan does not support empty organizations",
      "long_message": "This plan cannot be applied to an organization without members.",
      "code": "plan_does_not_support_empty_orgs"
    }
  ]
}
```

### PlanFreeTrialsDisabled

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Free trials disabled",
      "long_message": "Free trials are disabled for this plan",
      "code": "plan_free_trials_disabled"
    }
  ]
}
```

### PlanNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Plan not found",
      "long_message": "Plan not found",
      "code": "plan_not_found"
    }
  ]
}
```

### PlanSeatLimitExceeded

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Plan seat limit exceeded",
      "long_message": "Your organization has  members, but the requested plan would only support  members. Please remove members before switching to this plan.",
      "code": "plan_seat_limit_exceeded",
      "meta": {
        "plan_seat_limit": 0,
        "current_members": 0
      }
    }
  ]
}
```

### PriceTransitionNotAllowed

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Price transition not allowed",
      "long_message": "Price transition not allowed because ",
      "code": "price_transition_not_allowed"
    }
  ]
}
```

### SeatBasedBillingExceedsOrgMemberLimit

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Seat-based billing exceeds plan's organization member limit",
      "long_message": "The seat-based plan you are trying to create exceeds your Clerk plan's organization member limit. Adjust your seat limits to match your plan's limit or upgrade your subscription.",
      "code": "seat_based_billing_exceeds_org_member_limit"
    }
  ]
}
```

### SubscriptionAlreadyEnded

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Subscription already ended",
      "long_message": "Subscription is already ended",
      "code": "subscription_already_ended"
    }
  ]
}
```

### SubscriptionItemNoLongerActive

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Subscription item is no longer active",
      "long_message": "The subscription item is no longer the payer's active subscription item. It may have been changed by another request.",
      "code": "subscription_item_no_longer_active"
    }
  ]
}
```

### SubscriptionItemNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Subscription item not found",
      "long_message": "Subscription item not found",
      "code": "subscription_item_not_found"
    }
  ]
}
```

### SubscriptionItemNotInFreeTrial

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Subscription item is not in free trial",
      "long_message": "Subscription item is not in free trial",
      "code": "subscription_item_not_in_free_trial"
    }
  ]
}
```

### SubscriptionNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Subscription not found",
      "long_message": "Subscription not found",
      "code": "subscription_not_found"
    }
  ]
}
```

### SupportedBillingPeriodMismatch

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Supported billing period mismatch",
      "long_message": " cannot be set when supported_billing_periods is \"\"",
      "code": "supported_billing_period_mismatch",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### UnitPriceAmountPerBlockInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid unit price amount per block",
      "long_message": "Unit price '' tier  has invalid amount_per_block ''. Amount per block must be non-negative (>= 0)",
      "code": "unit_price_amount_per_block_invalid"
    }
  ]
}
```

### UnitPriceBlockSizeInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid unit price block size",
      "long_message": "Unit price block size '' is not supported. Supported block size: ",
      "code": "unit_price_block_size_invalid"
    }
  ]
}
```

### UnitPriceCurrencyInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid unit price currency",
      "long_message": "Unit price currency '' is not supported. Only '' is currently supported for unit prices",
      "code": "unit_price_currency_invalid"
    }
  ]
}
```

### UnitPriceEndsAfterBlockInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid tier range",
      "long_message": "Unit price '' tier  has ends_after_block () less than starts_at_block (). The end must be greater than or equal to the start",
      "code": "unit_price_ends_after_block_invalid"
    }
  ]
}
```

### UnitPriceFreeTierAfterPaidTier

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Free tier cannot follow a paid tier",
      "long_message": "Unit price '' tier  is free but a preceding tier is paid. Once a tier is paid, all subsequent tiers must also be paid",
      "code": "unit_price_free_tier_after_paid_tier"
    }
  ]
}
```

### UnitPriceNameInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid unit price name",
      "long_message": "Unit price name '' is not supported. Supported names: ",
      "code": "unit_price_name_invalid"
    }
  ]
}
```

### UnitPricesNotAllowedForUserPlans

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Unit prices not allowed for user plans",
      "long_message": "unit_prices can only be provided for organization plans, not user plans",
      "code": "unit_prices_not_allowed_for_user_plans"
    }
  ]
}
```

### UnitPriceStartsAtBlockInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid unit price starts at block",
      "long_message": "Unit price starts at block '' is not supported. Supported starts at block: ",
      "code": "unit_price_starts_at_block_invalid"
    }
  ]
}
```

### UnitPriceTierGapOrOverlapDetected

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Gap or overlap in tier ranges",
      "long_message": "Unit price '' tier  should start at block  but starts at . Tiers must be continuous with no gaps or overlaps",
      "code": "unit_price_tier_gap_or_overlap_detected"
    }
  ]
}
```

### UnitPriceTiersMissing

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Tiers missing",
      "long_message": "Unit price '' must have at least one tier defined",
      "code": "unit_price_tiers_missing"
    }
  ]
}
```

### UnitPriceUnlimitedTierMustBeLast

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Unlimited tier must be last",
      "long_message": "Unit price '' tier  has unlimited range (null ends_after_block) but is not the last tier. Only the last tier can be unlimited",
      "code": "unit_price_unlimited_tier_must_be_last"
    }
  ]
}
```

## Cookie

### InvalidCookie

`InvalidCookie` signifies an error when cookie is invalid

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "The provided cookie is invalid.",
      "long_message": "The provided cookie is invalid.",
      "code": "cookie_invalid"
    }
  ]
}
```

### InvalidRotatingToken

`InvalidRotatingToken` signifies an error when rotating token does not match the client's rotating token

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "The provided cookie is invalid.",
      "long_message": "The client's rotating key does not match the given one ",
      "code": "cookie_invalid"
    }
  ]
}
```

### MissingClaims

`MissingClaims` signifies an error when token is missing claim

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "The provided cookie is invalid.",
      "long_message": "The token is missing the following claims: ",
      "code": "cookie_invalid"
    }
  ]
}
```

## Deprecation

### APIEndpointDeprecated

filename: Status Code: 410
```json
{
  "errors": [
    {
      "message": "endpoint is deprecated and pending removal",
      "long_message": "",
      "code": "operation_deprecated"
    }
  ]
}
```

## Discounts

### DiscountAlreadyApplied

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Discount already applied",
      "long_message": "This subscription item already has an active discount applied",
      "code": "discount_already_applied"
    }
  ]
}
```

### DiscountInactive

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Discount inactive",
      "long_message": "This discount is not currently active",
      "code": "discount_inactive"
    }
  ]
}
```

### DiscountNotApplicableToSubscriptionItem

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Discount not applicable",
      "long_message": "This discount cannot be applied to this subscription item",
      "code": "discount_not_applicable_to_subscription_item"
    }
  ]
}
```

### DiscountNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Discount not found",
      "long_message": "The discount was not found",
      "code": "discount_not_found"
    }
  ]
}
```

## Domains

### DomainManagedByIntegration

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Domain is managed by an integration",
      "long_message": "The domains of this application are managed by . Update them from the  integration settings instead.",
      "code": "domain_managed_by_integration",
      "meta": {
        "integration": ""
      }
    }
  ]
}
```

### DomainUpdateForbidden

`DomainUpdateForbidden` signifies an error when trying to update an non production instance domain

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Domain update was forbidden",
      "long_message": "Domain can be only updated for production instances",
      "code": "domain_update_forbidden"
    }
  ]
}
```

### FeatureRequiresCustomDomain

`FeatureRequiresCustomDomain` signifies an error when a feature is blocked
because the instance only has a provider domain (e.g. vercel.app).

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "custom domain required",
      "long_message": " requires a custom domain. Add a custom domain to unlock this feature.",
      "code": "feature_requires_custom_domain"
    }
  ]
}
```

### InvalidProxyConfiguration

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "",
      "long_message": "Clerk Frontend API cannot be accessed through the proxy URL. Make sure your proxy is configured correctly.",
      "code": "invalid_proxy_configuration",
      "meta": {
        "param_name": "proxy_url"
      }
    }
  ]
}
```

### OperationNotAllowedOnPrimaryDomain

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "operation not allowed",
      "long_message": "This operation is not allowed on a primary domain. Try again with a satellite domain of the instance.",
      "code": "operation_not_allowed_on_primary_domain"
    }
  ]
}
```

### PrimaryDomainAlreadyExists

`PrimaryDomainAlreadyExists` signifies an error when a new domain is added as
primary when there is already once in the instance.
Currently, we only support a single primary domain per instance.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "primary domain already exists",
      "long_message": "Currently, only a single primary domain is supported and the current instance already has one. All new domains need to be set a satellites.",
      "code": "primary_domain_already_exists",
      "meta": {
        "param_name": "is_satellite"
      }
    }
  ]
}
```

### ProviderDomainOperationNotAllowedForAPI

`ProviderDomainOperationNotAllowedForAPI` reports a restricted provider-domain operation outside Platform API.

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "operation not allowed",
      "long_message": "* domains are not supported for production instances. Please purchase a domain then try again.",
      "code": "provider_domain_operation_not_allowed"
    }
  ]
}
```

### ProxyURLRequiredForProviderDomain

`ProxyURLRequiredForProviderDomain` signifies an error when a provider domain
(e.g., replit.app, vercel.app) is created without a proxy URL.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "proxy URL required",
      "long_message": "Provider domain  requires a proxy URL. Provider domains must be configured with a proxy.",
      "code": "proxy_url_required_for_provider_domain",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### TransactionalEmailRequiresVerifiedProductionDomain

`TransactionalEmailRequiresVerifiedProductionDomain` is returned when the
internal transactional-email surface is enabled on an instance whose active
sending domain is not a verified, customer-owned production domain.

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "verified production domain required",
      "long_message": "Transactional email requires an active, verified production domain that is not a shared provider domain.",
      "code": "transactional_email_requires_verified_production_domain"
    }
  ]
}
```

## Email

### DevDailyEmailRecipientLimitExceeded

`DevDailyEmailRecipientLimitExceeded` signifies that the workspace owning the
development instance has already emailed its daily limit of distinct
recipients across all of its development instances.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Development daily email recipient limit exceeded",
      "long_message": "This workspace has reached its daily limit of  distinct email recipients from development instances. Use test email addresses (https://go.clerk.com/test-emails), deploy a production instance, or contact support to raise the limit.",
      "code": "dev_daily_email_recipient_limit_exceeded",
      "meta": {
        "dev_daily_email_recipient_limit": 0
      }
    }
  ]
}
```

### DevMonthlyEmailLimitExceeded

`DevMonthlyEmailLimitExceeded` signifies an error when an email sending attempt is made while the development limit has already been reached

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Development monthly email limit exceeded",
      "long_message": "The monthly limit for email messages in development () has been reached. Please use test emails (https://go.clerk.com/test-emails) instead",
      "code": "dev_monthly_email_limit_exceeded",
      "meta": {
        "dev_monthly_email_limit": 0
      }
    }
  ]
}
```

### TransactionalEmailIdempotencyConflict

`TransactionalEmailIdempotencyConflict` is returned when an idempotency key
cannot represent the requested send without creating a second logical email.

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "idempotency key conflict",
      "long_message": "",
      "code": "transactional_email_idempotency_conflict"
    }
  ]
}
```

### TransactionalEmailSenderDomainMismatch

`TransactionalEmailSenderDomainMismatch` is returned when a caller-supplied
sender or reply-to address does not use the instance's bound sending domain.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "sender domain mismatch",
      "long_message": " must use the verified production sending domain .",
      "code": "transactional_email_sender_domain_mismatch",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

## Email template customization

### EmailTemplateCustomizationLocked

filename: Status Code: 423
```json
{
  "errors": [
    {
      "message": "Email template customization is locked",
      "long_message": "Email template customization is locked. Revert to the default template or contact support to regain customization access.",
      "code": "email_template_customization_locked"
    }
  ]
}
```

### EmailTemplateCustomizationRateLimited

filename: Status Code: 429
```json
{
  "errors": [
    {
      "message": "Email template customization rate limit exceeded",
      "long_message": "The email template customization rate limit was exceeded. Please try again later or contact support if you continue to experience issues.",
      "code": "email_template_customization_rate_limited"
    }
  ]
}
```

### EmailTemplateSuspiciousBlocked

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Email template update blocked",
      "long_message": "This email template update was detected as suspicious and has been blocked. If you believe this was a mistake, please contact support.",
      "code": "email_template_suspicious_blocked",
      "meta": {
        "remaining_suspicious_attempts_before_lock": 0
      }
    }
  ]
}
```

## Enterprise SSO

### EnterpriseSSOSignUpConnectionMissing

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "No Enterprise Connection for this sign-up",
      "long_message": "The current sign-up does not have a corresponding Enterprise Connection. Please check the domain of the provided email address.",
      "code": "enterprise_sso_sign_up_connection_missing"
    }
  ]
}
```

### SSOBypassDomainNotServed

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "user is not served by an enterprise connection",
      "long_message": "The user does not have a verified email address on a domain served by an enterprise connection, so they cannot be added to the SSO bypass allowlist.",
      "code": "sso_bypass_domain_not_served"
    }
  ]
}
```

## Features

### FeatureNotEnabled

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "not enabled",
      "long_message": "This feature is not enabled on this instance",
      "code": "feature_not_enabled"
    }
  ]
}
```

### FeatureNotEnabledWithMeta

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "not enabled",
      "long_message": "This feature is not enabled on this instance",
      "code": "feature_not_enabled",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FeatureRequiresDeviceVerificationURL

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Device verification page is not reachable",
      "long_message": "This feature requires a reachable device verification page. Configure a device verification URL or enable the Account Portal for this instance to continue.",
      "code": "feature_requires_device_verification_url"
    }
  ]
}
```

### FeatureRequiresEmailAddressAttributeEnabled

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Email address attribute must be enabled",
      "long_message": "This feature requires the email address attribute to be enabled. Please enable it in your instance settings to continue.",
      "code": "feature_requires_email_address_enabled"
    }
  ]
}
```

### FeatureRequiresOIDCProvider

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "not an OIDC provider",
      "long_message": "You are using the legacy OAuth 2.0 provider. Please migrate to the new OIDC compatible provider to use this feature",
      "code": "feature_requires_oidc_provider"
    }
  ]
}
```

### FeatureRequiresPSU

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "not a Progressive Sign Up instance",
      "long_message": " can only be used in instances that migrated to Progressive Sign Up. This feature is deprecated, please contact support if you need assistance.",
      "code": "feature_requires_progressive_sign_up"
    }
  ]
}
```

### NotImplemented

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "not implemented",
      "long_message": "Feature `` is not available yet",
      "code": "feature_not_implemented"
    }
  ]
}
```

## Forms

### FormAlreadyExists

`FormAlreadyExists` signifies an error when given resource already exists

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "The  already exists. Please try another.",
      "long_message": "The  already exists. Please try another.",
      "code": "form_already_exists",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormAtLeastOneOptionalParameterMissing

`FormAtLeastOneOptionalParameterMissing` signifies an error when at least one optional parameter must be provided

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "at least one parameter must be provided",
      "long_message": "at least one of `` must be provided",
      "code": "form_param_missing",
      "meta": {
        "param_names": [
          ""
        ]
      }
    }
  ]
}
```

### FormDisallowFutureDate

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Date values must not be in the future.",
      "long_message": "Date values must not be in the future.",
      "code": "form_disallow_future_date",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormDuplicateParameter

`FormDuplicateParameter` signifies an error when a duplicate parameter is found in a form

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is duplicate",
      "long_message": " included multiple times. There should only be one.",
      "code": "form_param_duplicate",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormDuplicateParameterValue

`FormDuplicateParameterValue` signifies an error when a value has been provided multiple times

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "duplicate values",
      "long_message": " contains duplicate values",
      "code": "form_param_duplicate",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormIdentifierExists

`FormIdentifierExists` signifies an error when given identifier already exists

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "That  is taken. Please try another.",
      "long_message": "That  is taken. Please try another.",
      "code": "form_identifier_exists",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormIdentifierExistsWithAnotherAccount

`FormIdentifierExistsWithAnotherAccount` signifies an error when given identifier already exists.
This is used to signal to a user that the identifier, phone number, is already associated with another account and should remove it from the other account.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "This  is already associated with an existing account. To use this  with this account, please remove it from your existing account first.",
      "long_message": "This  is already associated with an existing account. To use this  with this account, please remove it from your existing account first.",
      "code": "form_identifier_exists",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormIdentifierNotFound

`FormIdentifierNotFound` signifies an error when a required identifier is not found

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Couldn't find your account.",
      "long_message": "Couldn't find your account.",
      "code": "form_identifier_not_found",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormIncorrectCode

`FormIncorrectCode` signifies an error when the given code is incorrect

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is incorrect",
      "long_message": "Incorrect code",
      "code": "form_code_incorrect",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidDate

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Date values must be given in Unix millisecond timestamp format.",
      "long_message": "Date values must be given in Unix millisecond timestamp format.",
      "code": "form_param_invalid_date",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidEmailAddress

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " must be a valid email address.",
      "code": "form_param_format_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidEmailLocalPart

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " must be a valid email address local part.",
      "code": "form_param_format_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidEncodingParameterValue

`FormInvalidEncodingParameterValue` signifies an error when the given parameter has an invalid encoding

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "invalid character encoding",
      "long_message": " contains invalid UTF-8 characters",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidIdentifier

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " must be either a valid email address, a valid phone number according to E.164 international standard or a valid web3 wallet.",
      "code": "form_param_format_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidOrigin

`FormInvalidOrigin` signifies an error when the given value is not an exact origin

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " contains \"\", which is not a valid origin. Wildcards and patterns are not supported. Use an exact origin such as my-app://localhost, chrome-extension://mnhbilbfebpbokpjjamapdecdgieldho, or capacitor://localhost:3000",
      "code": "form_invalid_origin",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidParameterFormat

`FormInvalidParameterFormat` signifies an error when the given parameter has an invalid format

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": " is invalid.",
      "long_message": " is invalid.",
      "code": "form_param_format_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidParameterFormatBCP47

`FormInvalidParameterFormatBCP47` signifies an error when the given parameter does not match the BCP-47 format

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " must be a valid BCP-47 language tag.",
      "code": "form_param_format_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidParameterOnlyOneOfAllowed

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " is invalid. Only one of the following parameter values is allowed: ",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidParameterValue

`FormInvalidParameterValue` signifies an error when the given parameter has an invalid value

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " does not match one of the allowed values for parameter ",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidParameterValueMustBeNotEmpty

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " is invalid. Must be not empty",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidParameterValueWithAllowed

`FormInvalidParameterValueWithAllowed` signifies an error when the given parameter has an invalid value.
The difference with FormInvalidParameterValue is that this error also includes the allowed values

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " does not match the allowed values for parameter . Allowed values: ",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidPasswordLengthTooLong

`FormInvalidPasswordLengthTooLong` signifies an error when the password is invalid because of its length

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Passwords must be less than  characters.",
      "long_message": "Passwords must be less than  characters.",
      "code": "form_password_length_too_long",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidPasswordLengthTooShort

`FormInvalidPasswordLengthTooShort` signifies an error when the password is invalid because of its length

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Passwords must be  characters or more.",
      "long_message": "Passwords must be  characters or more.",
      "code": "form_password_length_too_short",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidPasswordNoLowercase

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Passwords must contain at least one lowercase character.",
      "long_message": "Passwords must contain at least one lowercase character.",
      "code": "form_password_no_lowercase",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidPasswordNoNumber

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Passwords must contain at least one number.",
      "long_message": "Passwords must contain at least one number.",
      "code": "form_password_no_number",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidPasswordNoSpecialChar

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Passwords must contain at least one of the following special characters: .",
      "long_message": "Passwords must contain at least one of the following special characters: .",
      "code": "form_password_no_special_char",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidPasswordNotStrongEnough

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Given password is not strong enough.",
      "long_message": "Given password is not strong enough.",
      "code": "form_password_not_strong_enough",
      "meta": {
        "param_name": "",
        "zxcvbn": {
          "suggestions": [
            ""
          ]
        }
      }
    }
  ]
}
```

### FormInvalidPasswordNoUppercase

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Passwords must contain at least one uppercase character.",
      "long_message": "Passwords must contain at least one uppercase character.",
      "code": "form_password_no_uppercase",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidPasswordSizeInBytesExceeded

`FormInvalidPasswordSizeInBytesExceeded` is returned when the password exceeds
the maximum size in bytes. A password with multi-byte characters can exceed it
while still under the maximum character length.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Your password is too long. Please use a shorter one.",
      "long_message": "Your password is too long. Please use a shorter one.",
      "code": "form_password_size_in_bytes_exceeded",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidPhoneNumber

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " must be a valid phone number according to E.164 international standard.",
      "code": "form_param_format_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidTime

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "invalid format",
      "long_message": " must contain a datetime specified in RFC3339 format (e.g. `2022-10-20T10:00:27.645Z`).",
      "code": "form_param_invalid_time",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidTypeParameter

`FormInvalidTypeParameter` signifies an error when a form parameter has the wrong type

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": "`` must be a ``.",
      "code": "form_param_type_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidUsernameCharacter

`FormInvalidUsernameCharacter` signifies an error when the given username does not match username regex

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": " can only contain .",
      "long_message": " can only contain .",
      "code": "form_username_invalid_character",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidUsernameLength

`FormInvalidUsernameLength` signifies an error when the given username does not have required length

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": " must be between  and  characters long.",
      "long_message": " must be between  and  characters long.",
      "code": "form_username_invalid_length",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidUsernameNeedsNonNumberCharCode

`FormInvalidUsernameNeedsNonNumberCharCode` signifies an error when the given username does not match username regex

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": " must contain one non-number character.",
      "long_message": " must contain one non-number character.",
      "code": "form_username_needs_non_number_char",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormInvalidWeb3WalletAddress

`FormInvalidWeb3WalletAddress` signifies an error when the given web3 wallet address is invalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " must be a valid web3 wallet address.",
      "code": "form_param_format_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormMetadataInvalidType

`FormMetadataInvalidType` signifies an error when the given metadata is not a valid key-value object

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": " must be a valid key-value object. To reset the , use an empty object (\"{}\").",
      "long_message": " must be a valid key-value object. To reset the , use an empty object (\"{}\").",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormMissingConditionalParameter

`FormMissingConditionalParameter` signifies an error when required parameter based on conditions is missing

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is missing",
      "long_message": "`` is required when `` is ``.",
      "code": "form_conditional_param_missing",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormMissingConditionalParameterOnExistence

`FormMissingConditionalParameterOnExistence` signifies an error when parameter is required because of the existence of another

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is missing",
      "long_message": "`` is required when `` is present.",
      "code": "form_conditional_param_missing",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormMissingParameter

`FormMissingParameter` signifies an error when an expected form parameter is missing

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is missing",
      "long_message": " must be included.",
      "code": "form_param_missing",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormMissingResource

`FormMissingResource` signifies an error when the form parameter is referring to a missing resource

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is missing",
      "long_message": "The resource associated with the supplied  was not found.",
      "code": "form_resource_not_found",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormNilParameter

`FormNilParameter` signifies an error when a nil parameter is found in a form

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Enter .",
      "long_message": "Enter .",
      "code": "form_param_nil",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormNotAllowedSpaceOrNonPrintable

`FormNotAllowedSpaceOrNonPrintable` signifies an error when the given parameter contains only whitespace or non-printable characters

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": " cannot contain only spaces.",
      "long_message": " cannot contain only spaces.",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormNotAllowedToDisableDefaultSecondFactor

`FormNotAllowedToDisableDefaultSecondFactor` signifies an error when trying to disable the default flag from a second-factor

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "The default second factor method can only be changed by assigning another method as the default.",
      "long_message": "The default second factor method can only be changed by assigning another method as the default.",
      "code": "form_disable_default_second_factor_not_allowed",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterArrayLengthMismatch

`FormParameterArrayLengthMismatch` signifies an error when a parallel array
parameter does not have the same number of items as the array it qualifies.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "length mismatch",
      "long_message": " must contain exactly one item for each item in .",
      "code": "form_param_array_length_mismatch",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterArraySizeExceeded

`FormParameterArraySizeExceeded` signifies an error when the given array exceeds the maximum allowed size

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "exceeds maximum size",
      "long_message": " should not exceed  items.",
      "code": "form_param_array_size_exceeded",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterDeprecated

`FormParameterDeprecated` is returned when a request includes a parameter that the
endpoint no longer accepts. The long message can name the replacement, such as a
different endpoint.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is deprecated",
      "long_message": " is deprecated and is no longer a valid parameter for this request.",
      "code": "form_param_deprecated",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterMaxLengthExceeded

`FormParameterMaxLengthExceeded` signifies an error when the given param value exceeds the maximum allowed length

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "exceeds maximum length",
      "long_message": " should not exceed  characters.",
      "code": "form_param_max_length_exceeded",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterMinLengthExceeded

`FormParameterMinLengthExceeded` signifies an error when the given param value is less than the minimum allowed length

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "does not reach minimum length",
      "long_message": " must be at least  characters long.",
      "code": "form_param_min_length_exceeded",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterNotAllowedConditionally

`FormParameterNotAllowedConditionally` signifies an error when parameter is not allowed based on condition

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is not allowed",
      "long_message": "`` isn't allowed when `` is .",
      "code": "form_conditional_param_disallowed",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterNotAllowedIfAnotherParameterIsPresent

`FormParameterNotAllowedIfAnotherParameterIsPresent` signifies an error when a parameter is present but
is not allowed because another parameter is also present

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is not allowed",
      "long_message": "`` isn't allowed when `` is present.",
      "code": "form_conditional_param_disallowed",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterSizeTooLarge

`FormParameterSizeTooLarge` signifies an error when a parameter exceeds the max allowed size

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "The given  exceeds the maximum allowed size of  bytes ( KB).",
      "long_message": "The given  exceeds the maximum allowed size of  bytes ( KB).",
      "code": "form_param_exceeds_allowed_size",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterValueConflict

`FormParameterValueConflict` signifies an error when two parameters that name
the same underlying value — typically a legacy name and the name that
replaces it — are both present but carry different values.

Either name is accepted on its own, and both can be sent together as long as
they agree.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "conflicting values",
      "long_message": "`` and `` refer to the same value, so they must match when both are sent.",
      "code": "form_param_value_conflict",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormParameterValueTooLarge

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Value too large",
      "long_message": "The value of  can't be greater than ",
      "code": "form_param_value_too_large",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormPasswordDigestInvalid

`FormPasswordDigestInvalid` signifies an error when the provided password\_digest is not valid for the provided password\_hasher

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "The provided  is not a valid  password hash.",
      "long_message": "The provided  is not a valid  password hash.",
      "code": "form_password_digest_invalid_code",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormPasswordMatchesIdentifier

`FormPasswordMatchesIdentifier` signifies an error when the chosen password
is identical to one of the account's identifiers (email address, phone
number or username).

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Password cannot match your email address, phone number or username. For account safety, please use a different password.",
      "long_message": "Password cannot match your email address, phone number or username. For account safety, please use a different password.",
      "code": "form_password_matches_identifier",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormPasswordValidationFailed

`FormPasswordValidationFailed` signifies a generic error when the password validation failed

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Incorrect password. Please try again.",
      "long_message": "Incorrect password. Please try again.",
      "code": "form_password_validation_failed",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormPublicClientRequiresPKCE

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": "PKCE is required for OAuth clients without a secret",
      "code": "form_public_client_requires_pkce",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormPwnedPassword

`FormPwnedPassword` signifies an error when the chosen password has been found in the pwned list

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Password has been found in an online data breach. For account safety, please .",
      "long_message": "Password has been found in an online data breach. For account safety, please .",
      "code": "form_password_pwned",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormUnknownParameter

`FormUnknownParameter` signifies an error when an unexpected parameter is found in a form

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is unknown",
      "long_message": " is not a valid parameter for this request.",
      "code": "form_param_unknown",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormUnknownParameterDueToDisabledFeature

`FormUnknownParameterDueToDisabledFeature` signifies an error when an unexpected parameter is found in a form due to a disabled feature

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is unknown",
      "long_message": " is not a valid parameter for this request.",
      "code": "form_param_unknown",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormUnverifiedIdentification

`FormUnverifiedIdentification` signifies an error when the identification included in the form is unverified

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is unverified",
      "long_message": "This identification needs to be verified before you can perform this action.",
      "code": "form_verification_needed",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormUsernameCannotBePhoneNumber

`FormUsernameCannotBePhoneNumber` signifies an error when the given username
is in canonical E.164 phone-number format. This is rejected regardless of
the configured username character set so that the value remains reserved
for the phone-number identifier and avoids ambiguity at sign-in.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": " cannot be a phone number.",
      "long_message": " cannot be a phone number. Please choose a different username.",
      "code": "form_username_cannot_be_phone_number",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### FormValidationFailed

`FormValidationFailed` is returned when one or more request parameters fail validation.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " is invalid",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

## Fraud

### FraudActionBlocked

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Action blocked",
      "long_message": "This action was detected as suspicious and has been blocked. If you believe this was a mistake, please contact support.",
      "code": "action_blocked"
    }
  ]
}
```

### FraudActionBlockedWithDetails

`FraudActionBlockedWithDetails` is FraudActionBlocked carrying the reference and
the instance's own message.

Same status, same code, same short message. The LONG message gains the
reference when there is one — see fraudActionBlockedLongMessage for why that
is not confined to `meta` — and `meta` is otherwise additive, so a client that
does not know the field still renders a sentence it understands, now with
something the customer can quote.

Callers that have no details keep using FraudActionBlocked. Details with
nothing in them produce exactly that, so "no details" has one spelling on the
wire instead of two.

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Action blocked",
      "long_message": "This action was detected as suspicious and has been blocked. If you believe this was a mistake, please contact support.",
      "code": "action_blocked"
    }
  ]
}
```

### ProtectCheckRequired

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Protect check required",
      "long_message": "A Protect check is required before this action can continue.",
      "code": "requires_protect_check",
      "meta": {
        "protect_check": ""
      }
    }
  ]
}
```

## Home URL

### HomeURLTaken

`HomeURLTaken` signifies an error when the root domain of the provided home\_url already in use by another application

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Domain already in use",
      "long_message": "The  root domain is already in use by another application.",
      "code": "home_url_taken",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### HomeURLTakenByProvider

`HomeURLTakenByProvider` signifies an error when the root domain of the
provided home\_url is already used by a provider-managed app.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Domain already in use by a  app",
      "long_message": "The  root domain is already in use by a  app. Delete the  app or contact  support to remove the domain before using it in Clerk.",
      "code": "home_url_taken",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### KnownHostingDomain

`KnownHostingDomain` signifies an error when the domain extracted from the provided home\_url belongs to a
known hosting service and cannot be used to deploy production apps

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Known hosting domain",
      "long_message": "The  domain cannot be used to deploy production apps.",
      "code": "known_hosting_domain",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### ReservedDomain

`ReservedDomain` signifies an error when the domain extracted from the provided home\_url is reserved by Clerk

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Domain reserved by Clerk",
      "long_message": "The  domain is reserved by Clerk.",
      "code": "reserved_domain",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### ReservedSubdomain

`ReservedSubdomain` signifies an error when the subdomain extracted from the provided home\_url is reserved by Clerk

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Reserved subdomain",
      "long_message": "The  subdomain is reserved by Clerk.",
      "code": "reserved_subdomain",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

## Identifications

### CreateSecondFactorUnverified

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Create failed",
      "long_message": "Unverified identifications cannot be a second factor",
      "code": "identification_create_second_factor_unverified"
    }
  ]
}
```

### IdentificationNotFound

`IdentificationNotFound` signifies an error when no identification is found with the given ID

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Resource not found",
      "long_message": "No resource was found for ID ",
      "code": "resource_not_found"
    }
  ]
}
```

### LastIdentificationDeletionFailed

`LastIdentificationDeletionFailed` signifies an error when trying to delete the last identification associated with a user

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Deletion failed",
      "long_message": "You cannot delete your last identification.",
      "code": "identification_deletion_failed"
    }
  ]
}
```

### LastIdentificationSetFor2FAFailed

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Update failed",
      "long_message": "You cannot set your last identification as second factor.",
      "code": "identification_update_failed"
    }
  ]
}
```

### LastRequiredIdentificationDeletionFailed

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Deleting your last  is prohibited",
      "long_message": "You are required to maintain at least one  in your account at all times",
      "code": "last_required_identification_deletion_failed"
    }
  ]
}
```

### UpdateSecondFactorUnverified

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Update failed",
      "long_message": "Cannot update second factor attributes for unverified identification",
      "code": "identification_update_second_factor_unverified"
    }
  ]
}
```

## Images

### ImageDecodingFailed

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Image decode error",
      "long_message": "The image could not be decoded. Please ensure the image is valid and try again.",
      "code": "request_body_invalid"
    }
  ]
}
```

### ImageNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Image not found",
      "long_message": "Image not found",
      "code": "image_not_found"
    }
  ]
}
```

### ImageTooLarge

`ImageTooLarge` signifies an error when the image being uploaded is too large to handle.

filename: Status Code: 413
```json
{
  "errors": [
    {
      "message": "Image too large",
      "long_message": "The image being uploaded is more than 10MB. Please choose a smaller one.",
      "code": "image_too_large"
    }
  ]
}
```

### ImageTypeNotSupported

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Unsupported image type",
      "long_message": "'' images are not currently supported. Please consult the API documentation for more information.",
      "code": "request_body_invalid"
    }
  ]
}
```

### RequestWithoutImage

`RequestWithoutImage` signifies an error when no image was present in the request.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Image file missing",
      "long_message": "There was no image file present in the request",
      "code": "form_param_missing"
    }
  ]
}
```

## Impersonation

### ImpersonationLimitExceeded

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Impersonation limit exceeded",
      "long_message": "Your application has reached the impersonation limit for your plan (/). The limit will reset at the beginning of the next billing period.",
      "code": "impersonation_limit_exceeded",
      "meta": {
        "limit": 0,
        "used": 0
      }
    }
  ]
}
```

## Instance keys

### SecretKeyIPNotAllowed

`SecretKeyIPNotAllowed` is returned when a secret key is used from an IP outside
its allowlist, or from an IP Clerk couldn't verify. It names the IP, never the list.

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "IP address not allowed",
      "long_message": "This secret key can only be used from the IP addresses in its allowlist.",
      "code": "secret_key_ip_not_allowed"
    }
  ]
}
```

## Instance settings

### DisabledInstanceRestriction

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is not allowed",
      "long_message": "`` isn't allowed to be set for this instance",
      "code": "disabled_instance_restriction",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

## Instances

### BreaksInstanceInvariant

`BreaksInstanceInvariant` is returned when the change would break a rule that the
instance's user settings require.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Breaks instance invariant",
      "long_message": " - This invariant is determined by your user settings",
      "code": "breaks_instance_invariant"
    }
  ]
}
```

### InstanceNotFound

`InstanceNotFound` signifies an error when no instance with the given ID was found

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Instance not found",
      "long_message": "No instance was found with id ",
      "code": "resource_not_found"
    }
  ]
}
```

## Internal

### BadRequest

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Bad request",
      "long_message": "Bad request",
      "code": "bad_request"
    }
  ]
}
```

### BadRequestWithMessage

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "",
      "long_message": "",
      "code": "bad_request"
    }
  ]
}
```

### Conflict

`Conflict` is returned when the request conflicts with the current state of the resource.

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Conflict",
      "long_message": "Conflict",
      "code": "conflict"
    }
  ]
}
```

### QuotaExceeded

403 - quota exceeded

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Quota exceeded",
      "long_message": "Quota exceeded, you have reached your limit.",
      "code": "quota_exceeded"
    }
  ]
}
```

### ResourceBusy

409 - resource locked

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "resource busy",
      "long_message": "This resource is currently being modified by another request. Please try again.",
      "code": "resource_locked"
    }
  ]
}
```

### ServiceUnavailable

`ServiceUnavailable` is returned when the service is temporarily unavailable.

filename: Status Code: 503
```json
{
  "errors": [
    {
      "message": "Service unavailable",
      "long_message": "Service unavailable",
      "code": "service_unavailable"
    }
  ]
}
```

### Unexpected

`Unexpected` is returned when the server hits an unexpected error.

filename: Status Code: 500
```json
{
  "errors": [
    {
      "message": "Oops, an unexpected error occurred",
      "long_message": "There was an internal error on our servers. We've been notified and are working on fixing it.",
      "code": "internal_clerk_error"
    }
  ]
}
```

## Invitations

### DuplicateInvitations

`DuplicateInvitations` denotes an error when there are already invitations
for the given email addresses

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "duplicate invitation",
      "long_message": "There are already pending invitations for the following email addresses: ",
      "code": "duplicate_record",
      "meta": {
        "email_addresses": [
          ""
        ]
      }
    }
  ]
}
```

### InvitationAlreadyAccepted

`InvitationAlreadyAccepted` denotes an error when someone tries to use
an invitation which is already accepted.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Invitation is already accepted, try signing in instead.",
      "long_message": "Invitation is already accepted, try signing in instead.",
      "code": "invitation_already_accepted"
    }
  ]
}
```

### InvitationAlreadyRevoked

`InvitationAlreadyRevoked` denotes an error when someone tries to revoke
an invitation which is already revoked.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Invitation is already revoked.",
      "long_message": "Invitation is already revoked.",
      "code": "invitation_already_revoked"
    }
  ]
}
```

### InvitationNotFound

`InvitationNotFound` denotes an error when there is no invitation with
the given id

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not found",
      "long_message": "No invitation was found with id .",
      "code": "resource_not_found"
    }
  ]
}
```

### InvitationsNotSupportedInInstance

`InvitationsNotSupportedInInstance` denotes an error when user is
trying to create an invitation on an instance that doesn't support it

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Invitations are only supported on instances that accept email addresses.",
      "long_message": "Invitations are only supported on instances that accept email addresses.",
      "code": "invitations_not_supported"
    }
  ]
}
```

### RevokedInvitation

`RevokedInvitation` denotes an error when the given invitation token
does not correspond to any invitations, which means that the invitation
has been removed.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "The invitation was revoked.",
      "long_message": "The invitation was revoked.",
      "code": "revoked_invitation"
    }
  ]
}
```

## JWT templates

### JWTTemplateNotFound

`JWTTemplateNotFound` signifies an error when a JWT template was not found by the provided attribute

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "JWT template not found",
      "long_message": "No JWT template exists with : ",
      "code": "resource_not_found"
    }
  ]
}
```

### JWTTemplateReservedClaim

`JWTTemplateReservedClaim` denotes an error when the provided template contains a reserved claim.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "reserved claim used",
      "long_message": "You can't use the reserved claim: ''",
      "code": "jwt_template_reserved_claim",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### SessionTokenTemplateNotDeletable

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "session token template cannot be deleted",
      "long_message": "This template cannot be deleted because it's a session token template",
      "code": "session_token_jwt_template"
    }
  ]
}
```

## Log drains

### LogDrainConfigInvalidStateTransition

`LogDrainConfigInvalidStateTransition` returns a 409 error indicating the
requested lifecycle action is not legal from the log drain's current state
(e.g. pausing a drain that is not active). The from/to are state names.

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Invalid log drain state transition",
      "long_message": "A log drain in the \"\" state cannot transition to \"\".",
      "code": "log_drain_config_invalid_state_transition"
    }
  ]
}
```

## Machine token

### MachineTokenReservedClaim

`MachineTokenReservedClaim` denotes an error when the provided machine token claims object contains a reserved claim.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "reserved claim used",
      "long_message": "You can't use the reserved claim: ''",
      "code": "machine_token_reserved_claim",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

## Network

### GatewayTimeout

`GatewayTimeout` signifies an error when a 3rd party service takes too long to respond.

filename: Status Code: 504
```json
{
  "errors": [
    {
      "message": "Gateway Timeout",
      "long_message": "A request to a 3rd party service timed out",
      "code": "gateway_timeout"
    }
  ]
}
```

## OAuth

### CustomOAuthProviderCannotUseDiscoveryURL

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "custom OAuth provider cannot use discovery URL",
      "long_message": "The custom OAuth provider cannot use the discovery URL. Please provide the necessary configuration manually.",
      "code": "custom_oauth_provider_cannot_use_discovery_url",
      "meta": {
        "param_name": "discovery_url"
      }
    }
  ]
}
```

### CustomOAuthProviderDiscoveryIssuerMismatch

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "issuer mismatch in custom OAuth provider discovery URL",
      "long_message": "The issuer in the discovery URL () does not match the issuer returned in the configuration ().",
      "code": "custom_oauth_provider_discovery_issuer_mismatch",
      "meta": {
        "param_name": "discovery_url"
      }
    }
  ]
}
```

### CustomOauthProviderDiscoveryServerRetrievalError

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "error retrieving OAuth response from provider's discovery URL",
      "long_message": "An error was encountered when attempting to retrieve metadata from the oauth url \"\": \"\"",
      "code": "custom_oauth_provider_discovery_server_retrieval_error",
      "meta": {
        "param_name": "discovery_url"
      }
    }
  ]
}
```

### ExternalAccountEmailAddressVerificationRequired

`ExternalAccountEmailAddressVerificationRequired` signifies an error when the external account requires email address verification

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Email address verification required",
      "long_message": "Your associated email address is required to be verified, because it was initially created as unverified.",
      "code": "external_account_email_address_verification_required"
    }
  ]
}
```

### ExternalAccountMissingRefreshToken

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Missing refresh token",
      "long_message": "We cannot refresh your OAuth access token because the server didn't provide a refresh token. Please re-connect your account.",
      "code": "external_account_missing_refresh_token"
    }
  ]
}
```

### ExternalAccountNotFound

`ExternalAccountNotFound` is returned when the external account from the OAuth
callback isn't found. It's also returned in transfer flows where the external
account exists but no user has been created for it yet.

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Invalid external account",
      "long_message": "The External Account was not found.",
      "code": "external_account_not_found"
    }
  ]
}
```

### OAuthMissingAccessToken

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Missing OAuth access token",
      "long_message": "OAuth access token is missing",
      "code": "oauth_missing_access_token"
    }
  ]
}
```

### OAuthMissingRefreshToken

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Cannot refresh OAuth access token",
      "long_message": "The current access token has expired and we cannot refresh it, because the authorization server hasn't provided us with a refresh token",
      "code": "oauth_missing_refresh_token"
    }
  ]
}
```

### OAuthSharedCredentialsStoredTokenNotRetrievable

`OAuthSharedCredentialsStoredTokenNotRetrievable` signifies an error when a
caller attempts to retrieve a stored provider access token that was minted
with Clerk's shared development OAuth credentials, even though the provider
now uses custom credentials. The stored token cannot be exposed; the account
must be reconnected to reissue a token under the custom credentials.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Stored access token not retrievable",
      "long_message": "This account's OAuth access token was issued with Clerk's shared development credentials and cannot be retrieved. Reconnect the account to reissue a token under your own OAuth credentials.",
      "code": "oauth_shared_credentials_stored_token_not_retrievable"
    }
  ]
}
```

### OAuthSharedCredentialsTokenRetrievalNotSupported

`OAuthSharedCredentialsTokenRetrievalNotSupported` signifies an error when a
caller attempts to retrieve a provider access token while the provider is
currently configured to use Clerk's shared development OAuth credentials.
Retrieving raw provider tokens is only supported for custom OAuth credentials.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Access token retrieval not supported with shared credentials",
      "long_message": "Retrieving the OAuth access token is not supported while using Clerk's shared development credentials. Configure custom OAuth credentials for this provider to retrieve access tokens.",
      "code": "oauth_shared_credentials_token_retrieval_not_supported"
    }
  ]
}
```

### OAuthTokenProviderNotEnabled

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "OAuth provider not enabled",
      "long_message": "Single-sign on for this OAuth provider is not enabled in the instance settings.",
      "code": "oauth_token_provider_not_enabled"
    }
  ]
}
```

### OAuthTokenRetrievalError

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Token retrieval failed",
      "long_message": "Failed to retrieve a new access token from the OAuth provider",
      "code": "oauth_token_retrieval_error",
      "meta": {
        "provider_error": ""
      }
    }
  ]
}
```

### UnsupportedOauthProvider

`UnsupportedOauthProvider` signifies an error when an instance tries to enable
an OAuth external provider which is not supported.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": " OAuth is not supported.",
      "long_message": " OAuth is not supported. Please contact us if you think this error should not appear.",
      "code": "oauth_unsupported_provider"
    }
  ]
}
```

## OAuth application

### DuplicateOAuthRedirectURI

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "duplicate redirect URI",
      "long_message": "the redirect URI already exists",
      "code": "duplicate_record"
    }
  ]
}
```

### OAuthApplicationConsentScreenCannotBeDisabled

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "consent screen cannot be disabled",
      "long_message": "Consent screen cannot be disabled for a dynamically registered OAuth Application",
      "code": "oauth_application_consent_screen_cannot_be_disabled"
    }
  ]
}
```

### OAuthApplicationConsentScreenRequiresConsentPath

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "consent screen requires a consent path",
      "long_message": "The consent screen cannot be enabled because there is no valid route to display it. The default consent page is hosted on the Account Portal, which is disabled for this instance, and no custom OAuth consent path has been configured. Configure an OAuth consent path or enable the Account Portal before enabling the consent screen.",
      "code": "oauth_application_consent_screen_requires_consent_path"
    }
  ]
}
```

## Organizations

### AlreadyAMemberOfOrganization

400 - User with given identifier is already a member of the
organization and cannot be added again

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "already a member",
      "long_message": " is already a member of the organization.",
      "code": "already_a_member_in_organization"
    }
  ]
}
```

### DefaultOrganizationRoleNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not found",
      "long_message": "Default organization role not found",
      "code": "resource_not_found"
    }
  ]
}
```

### ExclusiveOrganizationMembership

422 - Returned when a user cannot join (or be added to) an organization
because either the user already belongs to an exclusive organization or the
target organization is exclusive and the user has other memberships.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "exclusive organization membership",
      "long_message": "User cannot belong to multiple organizations because exclusive membership is enabled.",
      "code": "exclusive_organization_membership"
    }
  ]
}
```

### ExclusiveOrganizationMembershipExistingMembers

422 - Returned when enabling exclusive\_membership on an organization is
rejected because the organization already has members who belong to other
organizations in the same instance. Enabling the flag would retroactively
violate the invariant for those pre-existing members, so the flip is denied.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "exclusive organization membership cannot be enabled",
      "long_message": "Exclusive membership cannot be enabled because existing members of this organization belong to other organizations. Remove their other memberships before enabling exclusive membership.",
      "code": "exclusive_organization_membership_existing_members"
    }
  ]
}
```

### ForceOrganizationSelectionNotAllowedWhenOrganizationsDisabled

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "not allowed",
      "long_message": "`force_organization_selection` cannot be enabled when organizations are disabled. Please enable organizations first.",
      "code": "force_organization_selection_not_allowed_when_organizations_disabled"
    }
  ]
}
```

### MissingOrganizationPermission

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "missing permission",
      "long_message": "Current user is missing an organization permission.",
      "code": "missing_organization_permission",
      "meta": {
        "permissions": [
          ""
        ]
      }
    }
  ]
}
```

### NotAMemberInOrganization

`NotAMemberInOrganization` is returned when the user isn't a member of the
organization and the action is limited to its members.

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "not a member",
      "long_message": "Current user is not a member of the organization. Only organization members can perform this action.",
      "code": "not_a_member_in_organization"
    }
  ]
}
```

### OrganizationAlreadyHasSSOConnection

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "this organization already has an SSO connection",
      "long_message": "This organization already has an SSO connection.",
      "code": "organization_already_has_sso_connection",
      "meta": {
        "param_name": "organization_id"
      }
    }
  ]
}
```

### OrganizationCreatorNotFound

400 - Creator doesn't exist

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "creator not found",
      "long_message": "No users found with id .",
      "code": "organization_creator_not_found"
    }
  ]
}
```

### OrganizationDomainAlreadyExists

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "organizaton domain already exists",
      "long_message": "This domain is already used by another organization.",
      "code": "organization_domain_already_exists",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### OrganizationDomainAlreadyExistsForSameOrganization

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "organization domain already exists",
      "long_message": "This domain is already used by your organization.",
      "code": "organization_domain_already_exists_same_organization",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### OrganizationDomainBlocked

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "blocked email domain",
      "long_message": "This is a blocked email provider domain. Please use a different one.",
      "code": "organization_domain_blocked",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### OrganizationDomainCommon

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "common email domain",
      "long_message": "This is a common email provider domain. Please use a different one.",
      "code": "organization_domain_common",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### OrganizationDomainEnrollmentModeNotEnabled

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization enrollment mode not enabled",
      "long_message": "Enrollment mode  is not enabled for this instances's organizations.",
      "code": "organization_domain_enrollment_mode_not_enabled"
    }
  ]
}
```

### OrganizationDomainExistsForEnrollment

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "domain used for organization enrollment",
      "long_message": "This domain is already used for organization enrollment with verified domains. Please use a different one.",
      "code": "organization_domain_exists_for_enrollment"
    }
  ]
}
```

### OrganizationDomainExistsForEnterpriseConnection

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "domain exists for an organization enterprise connection",
      "long_message": "This domain is already used for your organization’s SSO. Please use a different one.",
      "code": "organization_domain_exists_for_enterprise_connection"
    }
  ]
}
```

### OrganizationDomainQuotaExceeded

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization domains quota exceeded",
      "long_message": "You have reached your limit of  domains per organization.",
      "code": "organization_domain_quota_exceeded"
    }
  ]
}
```

### OrganizationDomainsNotEnabled

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization domains not enabled",
      "long_message": "This instance does not have domains enabled for organizations.",
      "code": "organization_domains_not_enabled"
    }
  ]
}
```

### OrganizationInstanceRoleSetsQuotaExceeded

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization role sets for instance quota exceeded",
      "long_message": "You have reached your limit of  organization role sets per instance.",
      "code": "organization_instance_role_sets_quota_exceeded"
    }
  ]
}
```

### OrganizationInstanceRolesQuotaExceeded

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization roles for instance quota exceeded",
      "long_message": "You have reached your limit of  organization roles per instance.",
      "code": "organization_instance_roles_quota_exceeded"
    }
  ]
}
```

### OrganizationInvitationAlreadyAccepted

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "invitation has already been accepted",
      "long_message": "This invitation has already been accepted. Sign in instead.",
      "code": "organization_invitation_already_accepted"
    }
  ]
}
```

### OrganizationInvitationNotPending

404 - Invitation is not pending.

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not pending",
      "long_message": "The organization invitation is not in the 'pending' status.",
      "code": "organization_invitation_not_pending"
    }
  ]
}
```

### OrganizationInvitationNotUnique

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "organization invitation not unique",
      "long_message": "Organizations cannot have duplicate pending invitations for an email address.",
      "code": "organization_invitation_not_unique"
    }
  ]
}
```

### OrganizationInvitationRevoked

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "invitation has been revoked",
      "long_message": "This invitation has been revoked and cannot be used anymore.",
      "code": "organization_invitation_revoked_code"
    }
  ]
}
```

### OrganizationMemberLimitManagedByBilling

`OrganizationMemberLimitManagedByBilling` returns an error when trying to update
the member limit for an organization that is on a seat-based billing plan

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "member limit managed by Billing",
      "long_message": "This organization's member limit is managed by their subscription. It cannot be edited directly.",
      "code": "organization_member_limit_managed_by_billing",
      "meta": {
        "param_name": "max_allowed_memberships"
      }
    }
  ]
}
```

### OrganizationMembershipQuotaExceeded

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization membership quota exceeded",
      "long_message": "You have reached your limit of  organization memberships, including outstanding invitations.",
      "code": "organization_membership_quota_exceeded"
    }
  ]
}
```

### OrganizationMembershipQuotaExceededForSSO

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization membership quota exceeded for sso per org",
      "long_message": "The organization you are trying to join is full. Please contact support.",
      "code": "organization_membership_quota_exceeded_for_sso"
    }
  ]
}
```

### OrganizationMembershipSCIMManaged

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "membership role managed by directory sync",
      "long_message": "This membership is managed by a directory and cannot be changed manually.",
      "code": "organization_membership_managed_by_scim"
    }
  ]
}
```

### OrganizationMinimumPermissionsNeeded

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "minimum organization permissions needed",
      "long_message": "There has to be at least one organization member with the minimum required permissions",
      "code": "organization_minimum_permissions_needed"
    }
  ]
}
```

### OrganizationMissingCreatorRolePermissions

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "missing permissions for creator role",
      "long_message": "The creator role must contain the following permissions: ",
      "code": "organization_missing_creator_role_permissions"
    }
  ]
}
```

### OrganizationNameInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "invalid organization name",
      "long_message": "The organization name \"\" is invalid: ",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": "name"
      }
    }
  ]
}
```

### OrganizationNotEnabledInInstance

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "access denied",
      "long_message": "The organizations feature is not enabled for this instance. You can enable it at https://dashboard.clerk.com.",
      "code": "organization_not_enabled_in_instance"
    }
  ]
}
```

### OrganizationNotFound

`OrganizationNotFound` returns a 404 when an organization does not exist.

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not found",
      "long_message": "Given organization not found.",
      "code": "resource_not_found"
    }
  ]
}
```

### OrganizationNotFoundOrUnauthorized

`OrganizationNotFoundOrUnauthorized` is returned when the organization doesn't
exist or the caller can't access it. The response doesn't say which, so it
doesn't reveal whether the organization exists.

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not found or unauthorized",
      "long_message": "Given organization not found, or you don't have permission to access the organization",
      "code": "organization_not_found_or_unauthorized"
    }
  ]
}
```

### OrganizationPermissionNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not found",
      "long_message": "Organization permission not found",
      "code": "resource_not_found"
    }
  ]
}
```

### OrganizationQuotaExceeded

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization quota exceeded",
      "long_message": "You have reached your limit of  organizations. You can remove the organization limit by upgrading to a paid plan or using a production instance.",
      "code": "organization_quota_exceeded"
    }
  ]
}
```

### OrganizationRoleAssignedToMembers

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "role is assigned to organization members",
      "long_message": "The organization role is currently assigned to one or more organization members.",
      "code": "organization_role_assigned_members"
    }
  ]
}
```

### OrganizationRoleExistsInInvitations

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "role exists in pending organization invitations",
      "long_message": "The organization role exists in one or more pending organization invitations. Please revoke these invitations to proceed.",
      "code": "organization_role_exists_in_invitations"
    }
  ]
}
```

### OrganizationRoleNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not found",
      "long_message": "Organization role not found",
      "code": "resource_not_found",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### OrganizationRoleOnSetAssignedToUser

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "role is assigned to users",
      "long_message": "The role  is assigned to one or more users. Please re-assign the role to the users to proceed.",
      "code": "organization_role_on_set_assigned_to_user",
      "meta": {
        "role_key": ""
      }
    }
  ]
}
```

### OrganizationRolePermissionAssociationExists

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "permission already assigned to role",
      "long_message": "This organization permission is already associated to this organization role.",
      "code": "organization_role_permission_association_exists"
    }
  ]
}
```

### OrganizationRolePermissionAssociationNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "permission not assigned to role",
      "long_message": "This organization permission is not associated with the organization role.",
      "code": "organization_role_permission_association_not_found"
    }
  ]
}
```

### OrganizationRoleSetReassignmentContactSupport

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "contact support",
      "long_message": "This reassignment affects  memberships, contact support to complete this operation",
      "code": "organization_role_set_reassignment_contact_support"
    }
  ]
}
```

### OrganizationRoleSetReassignmentMappingsInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "reassignment mappings invalid",
      "long_message": "The role  is invalid in the reassignment mappings. It must be present in the new role set.",
      "code": "organization_role_set_reassignment_mappings_invalid",
      "meta": {
        "role_key": ""
      }
    }
  ]
}
```

### OrganizationRoleSetReassignmentMappingsMissing

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "reassignment mappings missing",
      "long_message": "The following roles are missing from the reassignment mappings: ",
      "code": "organization_role_set_reassignment_mappings_missing",
      "meta": {
        "role_keys": [
          ""
        ]
      }
    }
  ]
}
```

### OrganizationRoleUsedAsCreatorRole

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "role is used as the creator role",
      "long_message": "The organization role cannot be deleted as it is currently used as the creator role.",
      "code": "organization_role_default_creator_role"
    }
  ]
}
```

### OrganizationRoleUsedAsDomainDefaultRole

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "role is used as the domain default role",
      "long_message": "The organization role cannot be deleted as it is currently used as the default domain role.",
      "code": "organization_role_domain_default_role"
    }
  ]
}
```

### OrganizationsCannotBeEnabled

403 - Organizations cannot be enabled for this workspace.

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Organizations cannot be enabled for this workspace.",
      "long_message": "Organizations cannot be enabled for this workspace.",
      "code": "organizations_cannot_be_enabled"
    }
  ]
}
```

### OrganizationsDisableNotAllowed

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "cannot disable organizations",
      "long_message": "Cannot disable organizations because .",
      "code": "organizations_disable_not_allowed"
    }
  ]
}
```

### OrganizationSlugsDisabled

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization slugs not enabled",
      "long_message": "This instance does not have slugs enabled for organizations.",
      "code": "organization_slugs_disabled"
    }
  ]
}
```

### OrganizationSystemPermissionNotModifiable

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "organization system permission cannot be modified",
      "long_message": "This organization permission cannot be modified because it is a system permission.",
      "code": "organization_system_permission_not_modifiable"
    }
  ]
}
```

### OrganizationTooLarge

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Organization too large",
      "long_message": "Organization size is above the API limit",
      "code": "organization_too_large",
      "meta": {
        "param_name": "organization_id"
      }
    }
  ]
}
```

### OrgCreationLimitExceededError

403 - Organization Creation Limit Exceeded

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Organization Creation Limit Exceeded",
      "long_message": "You have exceeded the maximum number of organizations you can create.",
      "code": "org_creation_limit_exceeded"
    }
  ]
}
```

### PersonalAccountsNotAllowed

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "personal accounts are not allowed",
      "long_message": "You must maintain at least one organization membership since personal accounts are not allowed on the application",
      "code": "personal_accounts_not_allowed"
    }
  ]
}
```

### RoleMigrationInProgress

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "migration in progress",
      "long_message": "Cannot modify role set while role reassignment is in progress. Please wait for the migration to complete.",
      "code": "role_migration_in_progress"
    }
  ]
}
```

## Passkeys

### PasskeyNotRegistered

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not registered",
      "long_message": "Passkey is not registered.",
      "code": "passkey_not_registered"
    }
  ]
}
```

## Platform

### PlatformAPIAuthStrategyNotAllowed

`PlatformAPIAuthStrategyNotAllowed` signifies that the endpoint does not accept the authentication strategy used for the request.

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Authentication method not allowed",
      "long_message": "This endpoint does not accept the credential type used. Use an authentication method allowed for this operation.",
      "code": "platform_api_auth_strategy_not_allowed"
    }
  ]
}
```

## Pricing

### UnsupportedSubscriptionPlanFeatures

filename: Status Code: 402
```json
{
  "errors": [
    {
      "message": "Unsupported plan features",
      "long_message": "Some features are not supported in your current plan. Upgrade your subscription to unlock them.",
      "code": "unsupported_subscription_plan_features",
      "meta": {
        "unsupported_features": [
          ""
        ]
      }
    }
  ]
}
```

## Promo codes

### CheckoutPromoCodeInvalid

`CheckoutPromoCodeInvalid` is returned when a promo code entered at checkout
can't be applied: the code doesn't exist, is archived, its discount's
redemption window isn't open, or the discount doesn't target this checkout's
price, period, or currency. The response doesn't say which, so codes can't be
probed. Show it as a single "Invalid promo code" state.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid promo code",
      "long_message": "This promo code cannot be applied to this checkout",
      "code": "checkout_promo_code_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

## Public keys

### PublicKeyNotFound

`PublicKeyNotFound` signifies an error when no public key was found with the given id

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Public key not found",
      "long_message": "No public key was found with id ",
      "code": "resource_not_found"
    }
  ]
}
```

## Redirect URLs

### RedirectURLNotFound

`RedirectURLNotFound` signifies an error when a RedirectURL was not found by the provided attribute

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Redirect url not found",
      "long_message": "No RedirectURL exists with : ",
      "code": "resource_not_found"
    }
  ]
}
```

## Requests

### BulkSizeExceeded

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "bulk size exceeded",
      "long_message": "Parameters exceed the maximum allowed bulk processing size of .",
      "code": "bulk_size_exceeded"
    }
  ]
}
```

### FailedToParseRequestBody

`FailedToParseRequestBody` is returned when a field in the request body has the wrong type.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is invalid",
      "long_message": " is invalid. Received , must be of type .",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### InfiniteRedirectLoop

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Infinite redirect loop detected",
      "long_message": "Infinite redirect loop detected. That usually means that we were not able to determine the auth state for this request.",
      "code": "infinite_redirect_loop"
    }
  ]
}
```

### InvalidAPIVersion

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "invalid API version",
      "long_message": "Invalid Clerk API version: ",
      "code": "api_version_invalid"
    }
  ]
}
```

### InvalidJSONRequestBody

`InvalidJSONRequestBody` is returned when the request body is malformed JSON. The
long message says what's wrong, such as the byte offset of a syntax error.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Request body invalid",
      "long_message": "Invalid JSON at byte offset ",
      "code": "request_body_invalid"
    }
  ]
}
```

### InvalidRequestBody

`InvalidRequestBody` signifies an error when the body of the request does not conform to the expected format

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Request body invalid",
      "long_message": "The request body is invalid. Please consult the API documentation for more information.",
      "code": "request_body_invalid"
    }
  ]
}
```

### MalformedPublishableKey

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Malformed publishable key",
      "long_message": "Ensure the provided publishable key () is the one displayed in Dashboard",
      "code": "malformed_publishable_key"
    }
  ]
}
```

### MalformedRequestParameters

`MalformedRequestParameters` signifies an error when the request parameters are malformed and result in parsing errors

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Malformed request parameters",
      "long_message": "The request parameters are malformed and could not be parsed",
      "code": "malformed_request_parameters"
    }
  ]
}
```

### MissingOneOfQueryParameters

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Missing query parameter",
      "long_message": "Either of the following query parameters must be provided: .",
      "code": "missing_query_parameter"
    }
  ]
}
```

### MissingQueryParameter

`MissingQueryParameter` is returned when the request is missing a required query parameter.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Missing query parameter ''",
      "long_message": "The query parameter '' is missing from the request. Please consult the API documentation for more information.",
      "code": "missing_query_parameter"
    }
  ]
}
```

### RequestBodyTooLarge

filename: Status Code: 413
```json
{
  "errors": [
    {
      "message": "Request body too large",
      "long_message": "The request body exceeds the maximum allowed size of  bytes.",
      "code": "request_body_too_large"
    }
  ]
}
```

### UnsupportedContentType

`UnsupportedContentType` signifies an error when provided content type is unsupported

filename: Status Code: 415
```json
{
  "errors": [
    {
      "message": "Content-Type is unsupported",
      "long_message": "Content-Type  is unsupported. You should use  instead.",
      "code": "unsupported_content_type"
    }
  ]
}
```

## SAML

### SAMLConnectionCantBeActivated

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "SAML Connection can't be activated",
      "long_message": "You have to provide the  before you are able to activate this connection.",
      "code": "saml_connection_cant_be_activated"
    }
  ]
}
```

### SAMLFailedToFetchIDPMetadata

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Failed to fetch IdP metadata",
      "long_message": "We failed to fetch the IdP metadata. If the error persists, please provide the IdP configuration data explicitly.",
      "code": "saml_failed_to_fetch_idp_metadata"
    }
  ]
}
```

### SAMLFailedToParseIDPMetadata

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Failed to parse IdP metadata",
      "long_message": "We failed to parse the IdP metadata. If the error persists, please provide the IdP configuration data explicitly.",
      "code": "saml_failed_to_parse_idp_metadata"
    }
  ]
}
```

### SAMLMetadataMissingFields

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "IdP metadata is missing required fields",
      "long_message": "The IdP metadata is missing the following required fields: ",
      "code": "saml_metadata_missing_fields",
      "meta": {
        "missing_fields": [
          ""
        ]
      }
    }
  ]
}
```

## SCIM

### SCIMAttributeManagedByDirectory

`SCIMAttributeManagedByDirectory` returns a 409 Conflict error when attempting to
update an attribute that is managed by a directory.

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "attribute managed by directory sync",
      "long_message": " is not allowed to be updated. This attribute is managed by the directory.",
      "code": "attribute_managed_by_scim",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### SCIMDirectoryDisabled

`SCIMDirectoryDisabled` returns an error when attempting to trigger a pull
sync on a disabled directory.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "directory disabled",
      "long_message": "This directory is disabled.",
      "code": "scim_directory_disabled"
    }
  ]
}
```

### SCIMDirectoryEnterpriseConnectionAlreadyUsed

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "enterprise connection already in use",
      "long_message": "This enterprise connection is already associated with another directory.",
      "code": "scim_directory_enterprise_connection_already_used",
      "meta": {
        "param_name": "scim_connection_id"
      }
    }
  ]
}
```

### SCIMDirectoryOrganizationAlreadyUsed

`SCIMDirectoryOrganizationAlreadyUsed` is returned when creating a SCIM directory
for an organization that already has one.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "organization already has a SCIM directory",
      "long_message": "This organization is already associated with another SCIM directory.",
      "code": "scim_directory_organization_already_used",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### SCIMDirectoryPullModeNotConfigured

`SCIMDirectoryPullModeNotConfigured` returns an error when attempting to
trigger a pull sync on a directory that is not configured for
pull-mode sync.

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "directory not configured for pull-mode sync",
      "long_message": "This directory is not configured for pull-mode sync.",
      "code": "scim_directory_pull_mode_not_configured"
    }
  ]
}
```

### SCIMDirectorySyncThrottled

`SCIMDirectorySyncThrottled` returns a 409 Conflict error when a manual pull
sync is requested while one is already running or another just started.

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "sync already in progress",
      "long_message": "A sync for this directory is already running.",
      "code": "scim_directory_sync_throttled"
    }
  ]
}
```

### SCIMGroupNotFoundInDirectory

`SCIMGroupNotFoundInDirectory` returns a validation error for a group ID that
cannot be found in the requested directory.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "group not found in directory",
      "long_message": "Group \"\" was not found in directory \"\". Retrieve the current group IDs using GET /v1/directories//groups and retry with a group ID from this directory.",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": "scim_group_id"
      }
    }
  ]
}
```

## Session refresh

### SessionRefreshConsumedExpiredSessionToken

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "expired session token consumed",
      "long_message": "The provided expired session token was already consumed in a previous refresh request",
      "code": "session_refresh_expired_session_token_consumed"
    }
  ]
}
```

### SessionRefreshExpiredSessionTokenInvalid

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "Invalid expired_token param",
      "long_message": "The session token provided could not be successfully verified",
      "code": "expired_session_token_invalid"
    }
  ]
}
```

### SessionRefreshExpiredSessionTokenTooOld

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "session token too old",
      "long_message": "The provided expired session token is too old",
      "code": "session_refresh_expired_session_token_too_old"
    }
  ]
}
```

### SessionRefreshInactiveSession

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "session inactive",
      "long_message": "The provided session is not active",
      "code": "session_refresh_inactive_session"
    }
  ]
}
```

### SessionRefreshIneligibleToken

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "expired session token ineligible",
      "long_message": "The provided expired session token is not eligible for refresh",
      "code": "session_refresh_session_token_ineligible"
    }
  ]
}
```

### SessionRefreshInvalidRequestOrigin

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "Request origin is invalid",
      "long_message": "The request_origin parameter could not be parsed",
      "code": "refresh_request_origin_invalid"
    }
  ]
}
```

### SessionRefreshMissingAZP

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "missing 'azp' claim",
      "long_message": "No 'azp' claim present in the provided expired session token",
      "code": "expired_session_token_missing_azp"
    }
  ]
}
```

### SessionRefreshMissingIAT

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "missing 'iat' claim",
      "long_message": "No 'iat' claim present in the provided expired session token",
      "code": "session_refresh_expired_session_token_missing_iat"
    }
  ]
}
```

### SessionRefreshMissingSID

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "missing 'sid' claim",
      "long_message": "No 'sid' claim present in the provided expired session token",
      "code": "expired_session_token_missing_sid"
    }
  ]
}
```

### SessionRefreshRequestOriginAZPMismatch

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "Request origin does not match azp claim",
      "long_message": "The request_origin parameter does not match the 'azp' claim of expired_token",
      "code": "refresh_request_origin_azp_mismatch"
    }
  ]
}
```

### SessionRefreshSessionNotFound

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "Session not found",
      "long_message": "No session was found with id ",
      "code": "session_refresh_session_not_found"
    }
  ]
}
```

### SessionRefreshSIDMismatch

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "Session ID does not match the 'sid' claim",
      "long_message": "The 'sid' claim of the provided expired session token does not match the session ID provided in the request path",
      "code": "refresh_sid_mismatch"
    }
  ]
}
```

### SessionRefreshTokenNotFound

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "Refresh token not found",
      "long_message": "The provided refresh token was not found",
      "code": "refresh_token_not_found"
    }
  ]
}
```

### SessionRefreshUserNotFound

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "user not found",
      "long_message": "The provided user was not found",
      "code": "session_refresh_user_not_found"
    }
  ]
}
```

## Sessions

### CannotCreateSessionWhenImpersonationIsPresent

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "unable to create session",
      "long_message": "Unable to create new session when an impersonation session is present. Please sign out first.",
      "code": "session_creation_not_allowed"
    }
  ]
}
```

### Deprovisioned

filename: Status Code: 401
```json
{
  "errors": [
    {
      "message": "account deprovisioned",
      "long_message": "Your account is deprovisioned",
      "code": "deprovisioned"
    }
  ]
}
```

### DeprovisionedBadRequest

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "account deprovisioned",
      "long_message": "The target user's account has been deprovisioned according to their external identity provider",
      "code": "deprovisioned"
    }
  ]
}
```

### InvalidSessionToken

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Invalid session token",
      "long_message": "The token provided could not be successfully verified",
      "code": "invalid_session_token"
    }
  ]
}
```

### ReverificationNotFound

`ReverificationNotFound` signifies an error when no reverification (step-up) with the given id was found on the session

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Reverification not found",
      "long_message": "No reverification was found with id ",
      "code": "resource_not_found"
    }
  ]
}
```

### SessionNotFound

`SessionNotFound` signifies an error when no session with the given ID was found

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Session not found",
      "long_message": "No session was found with id ",
      "code": "resource_not_found"
    }
  ]
}
```

## Sign-in

### IdentificationClaimed

`IdentificationClaimed` signifies an error when the requested identification is already claimed by another user

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Identification claimed by another user",
      "long_message": "One or more identifiers on this sign up have since been connected to a different User. Please sign up again.",
      "code": "identification_claimed"
    }
  ]
}
```

### InvalidClientStateForAction

`InvalidClientStateForAction` signifies an error when trying to perform an invalid action for the current client state

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Invalid action",
      "long_message": "We were unable to complete  for this Client. ",
      "code": "client_state_invalid"
    }
  ]
}
```

## Sign-in tokens

### SignInTokenCannotBeRevoked

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "cannot revoke",
      "long_message": "Sign in token cannot be revoked because its status is . Only pending tokens can be revoked.",
      "code": "sign_in_token_cannot_be_revoked_code"
    }
  ]
}
```

## Sign-up

### InvalidValueForSignUpMode

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "is not allowed",
      "long_message": "`` isn't allowed to be `` when sign-up mode is set to ",
      "code": "sign_up_mode_restricted_invalid_value",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### SignUpCannotBeUpdated

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "Sign up cannot be updated",
      "long_message": "This sign up has reached a terminal state and cannot be updated",
      "code": "sign_up_cannot_be_updated"
    }
  ]
}
```

## Signing keys

### SigningKeyNotFound

`SigningKeyNotFound` signifies an error when no signing key with the given ID was found

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Signing key not found",
      "long_message": "No signing key was found with id ",
      "code": "resource_not_found"
    }
  ]
}
```

## SMS

### DevMonthlySMSLimitExceeded

`DevMonthlySMSLimitExceeded` signifies an error when an SMS sending attempt is made while the development limit has already been reached

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Development monthly SMS limit exceeded",
      "long_message": "Operation cannot be completed because the monthly limit for SMS messages in development () has been reached.",
      "code": "dev_monthly_sms_limit_exceeded",
      "meta": {
        "dev_monthly_sms_limit": 0
      }
    }
  ]
}
```

### SMSCountryRemovalRestricted

`SMSCountryRemovalRestricted` signals that the caller tried to remove one or more
tier B-F countries from the SMS blocklist on an instance whose plan lacks the
phone\_code feature. Removing those countries is restricted to prevent SMS pumping abuse on
free/dev instances; activating them requires upgrading the plan or contacting support.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "SMS country removal restricted",
      "long_message": "Cannot remove the following countries from the SMS blocklist without an upgraded plan: . Contact support to activate these countries.",
      "code": "sms_country_removal_restricted",
      "meta": {
        "country_codes": [
          ""
        ]
      }
    }
  ]
}
```

### SMSSendError

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Sending SMS failed",
      "long_message": "Sending SMS failed. Please contact support or try again later.",
      "code": "sms_send_error"
    }
  ]
}
```

### SMSVerificationNotYetSent

`SMSVerificationNotYetSent` signifies that a user attempted to use an SMS verification code before it was delivered.
e.g. by immediately typing in a random or incorrect code after preparing a sign\_in

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "verification code not yet delivered",
      "long_message": "Your verification code is still being delivered. Please check your messages in a moment and try again.",
      "code": "sms_verification_not_yet_sent"
    }
  ]
}
```

### WhatsAppChannelNotEnabled

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "WhatsApp channel not enabled",
      "long_message": "The 'whatsapp' channel is not available for this instance.",
      "code": "whatsapp_channel_not_enabled",
      "meta": {
        "param_name": "channel"
      }
    }
  ]
}
```

## Templates

### InvalidTemplateBody

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Invalid template body",
      "long_message": "This template body is invalid and cannot be rendered successfully, please check for syntax errors",
      "code": "invalid_template_body",
      "meta": {
        "param_name": "body"
      }
    }
  ]
}
```

### RequiredVariableMissing

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "should contain {{}} variable",
      "long_message": "Body should contain the {{}} variable",
      "code": "required_variable_missing",
      "meta": {
        "param_name": "body"
      }
    }
  ]
}
```

### TemplateBodyModificationNotAllowed

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Template body cannot be modified",
      "long_message": "The body of template with slug  can't be modified",
      "code": "template_body_modification_restricted"
    }
  ]
}
```

### TemplateDeletionRestricted

`TemplateDeletionRestricted` signifies an error when a deletion is attempted for a built-in (non-custom) template

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Template deletion restricted",
      "long_message": "Template with slug  can't be deleted",
      "code": "template_deletion_restricted"
    }
  ]
}
```

### TemplateNotFound

`TemplateNotFound` signifies an error when no template with given slug was found

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "Template not found",
      "long_message": "No template was found with slug ",
      "code": "resource_not_found"
    }
  ]
}
```

### TemplateRevertRestricted

`TemplateRevertRestricted` signifies an error when a custom template is attempted to be reverted

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Template revert restricted",
      "long_message": "Template with slug  can't be reverted",
      "code": "template_revert_error"
    }
  ]
}
```

### TemplateTypeUnsupported

`TemplateTypeUnsupported` signifies an error when an invalid template type is provided

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Template type not supported",
      "long_message": "Template type  is not supported",
      "code": "template_type_unsupported"
    }
  ]
}
```

## TOTP

### InvalidTOTPSecret

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "invalid TOTP secret",
      "long_message": "The TOTP secret is invalid, please provide a valid one base32 encoded",
      "code": "invalid_totp_secret_code"
    }
  ]
}
```

## URLs

### InsecureURL

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Insecure URL",
      "long_message": "Please provide a secure URL (https)",
      "code": "insecure_url",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

## User settings

### ResourceNotFound

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not found",
      "long_message": "Resource not found",
      "code": "resource_not_found"
    }
  ]
}
```

## Users

### DeleteLinkedCommNotAllowed

`DeleteLinkedCommNotAllowed` signifies an error when trying to delete a linked communication

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Deleting a linked email address is not allowed",
      "long_message": "This email address is linked to one or more Connected Accounts. Remove the Connected Account before deleting this email address.",
      "code": "delete_linked_identification_disallowed"
    }
  ]
}
```

### IncorrectPassword

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "incorrect password",
      "long_message": "The provided password is not the one the user has set",
      "code": "incorrect_password"
    }
  ]
}
```

### IncorrectTOTP

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "incorrect TOTP",
      "long_message": "The provided TOTP code is incorrect",
      "code": "totp_incorrect_code"
    }
  ]
}
```

### InvalidLengthTOTP

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "invalid length",
      "long_message": "The provided TOTP code must be 6 characters long.",
      "code": "totp_invalid_length"
    }
  ]
}
```

### NoPasswordSet

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "no password set",
      "long_message": "This user does not have a password set for their account",
      "code": "no_password_set"
    }
  ]
}
```

### PasswordDisabled

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "password disabled",
      "long_message": "Password is disabled for this instance. Cannot force a password reset.",
      "code": "password_disabled"
    }
  ]
}
```

### TOTPDisabled

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "TOTP is disabled",
      "long_message": "This user does not have TOTP enabled in their account",
      "code": "totp_disabled"
    }
  ]
}
```

### UserBanned

`UserBanned` signifies an error when a user is banned

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "User banned",
      "long_message": "You have been banned. If you think this was by mistake, please contact support.",
      "code": "user_banned"
    }
  ]
}
```

### UserDataMissing

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "missing data",
      "long_message": "\"\" data doesn't match user requirements set for this instance",
      "code": "form_data_missing",
      "meta": {
        "param_names": [
          ""
        ]
      }
    }
  ]
}
```

### UserDeactivated

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "User deactivated",
      "long_message": "You have been deactivated. Please contact support.",
      "code": "user_deactivated"
    }
  ]
}
```

### UserFirstNameInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "invalid first name",
      "long_message": "The first name \"\" is invalid: ",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### UserLastNameInvalid

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "invalid last name",
      "long_message": "The last name \"\" is invalid: ",
      "code": "form_param_value_invalid",
      "meta": {
        "param_name": ""
      }
    }
  ]
}
```

### UserNotFound

`UserNotFound` signifies an error when no user is found with the given ID

filename: Status Code: 404
```json
{
  "errors": [
    {
      "message": "not found",
      "long_message": "No user was found with id ",
      "code": "resource_not_found"
    }
  ]
}
```

### UserQuotaExceeded

filename: Status Code: 403
```json
{
  "errors": [
    {
      "message": "user quota exceeded",
      "long_message": "You have reached your limit of  users. ",
      "code": "user_quota_exceeded"
    }
  ]
}
```

### UserSCIMManaged

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "user managed by directory sync",
      "long_message": "This user is managed by a directory and cannot be deleted manually.",
      "code": "user_managed_by_scim"
    }
  ]
}
```

## Verification

### VerificationAlreadyVerified

`VerificationAlreadyVerified` signifies an error when verification has already been verified

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "already verified",
      "long_message": "This verification has already been verified.",
      "code": "verification_already_verified"
    }
  ]
}
```

### VerificationCodeNotSent

`VerificationCodeNotSent` is an attempt against a verification whose code
never went out: the send failed after the prepare had already returned. Tell
the user to request a new code rather than that theirs is incorrect.

filename: Status Code: 422
```json
{
  "errors": [
    {
      "message": "Verification code was not sent",
      "long_message": "We could not send a verification code for this request. Please request a new code.",
      "code": "verification_code_not_sent"
    }
  ]
}
```

### VerificationCodeRateLimitExceeded

filename: Status Code: 429
```json
{
  "errors": [
    {
      "message": "Too many verification code requests",
      "long_message": "Too many verification code requests. Please try again later.",
      "code": "verification_code_rate_limit_exceeded"
    }
  ]
}
```

### VerificationCodeTooManyAttempts

`VerificationCodeTooManyAttempts` is the SMS provider declining to check the
code; no attempt was counted. The wait travels in Retry-After.

filename: Status Code: 429
```json
{
  "errors": [
    {
      "message": "Too many verification attempts",
      "long_message": "Too many attempts to verify this code. Please wait before trying again.",
      "code": "verification_code_too_many_attempts"
    }
  ]
}
```

### VerificationCodeTooManyRequests

filename: Status Code: 429
```json
{
  "errors": [
    {
      "message": "Too many verification code requests",
      "long_message": "Too many verification code requests. Please wait at least 30 seconds to receive your code before trying again.",
      "code": "verification_code_too_many_requests"
    }
  ]
}
```

### VerificationExpired

`VerificationExpired` signifies an error when verification has expired

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "expired",
      "long_message": "This verification has expired. You must create a new one.",
      "code": "verification_expired"
    }
  ]
}
```

### VerificationFailed

`VerificationFailed` signifies an error when verification fails

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "failed",
      "long_message": "Too many failed attempts. You have to try again with the same or another method.",
      "code": "verification_failed"
    }
  ]
}
```

### VerificationInvalidStrategy

`VerificationInvalidStrategy` signifies an error when the given strategy is not valid for current verification

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "has invalid strategy",
      "long_message": "The strategy is not valid for the current verification.",
      "code": "verification_strategy_invalid"
    }
  ]
}
```

### VerificationNotSent

`VerificationNotSent` signifies an error when verification email was not sent

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "not sent",
      "long_message": "You need to send a verification code before attempting to verify.",
      "code": "verification_not_sent"
    }
  ]
}
```

### VerificationUnknownStatus

`VerificationUnknownStatus` signifies an unexpected error when unknown verification status is found

filename: Status Code: 500
```json
{
  "errors": [
    {
      "message": "Unknown verification status",
      "long_message": "Found unknown verification status ",
      "code": "verification_status_unknown"
    }
  ]
}
```

## Waitlist

### WaitlistEntryAlreadyCompleted

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Waitlist entry already completed",
      "long_message": "The waitlist entry has already been completed.",
      "code": "waitlist_entry_already_completed"
    }
  ]
}
```

### WaitlistEntryAlreadyInvited

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Waitlist entry already invited",
      "long_message": "The waitlist entry has already been invited.",
      "code": "waitlist_entry_already_invited"
    }
  ]
}
```

### WaitlistEntryAlreadyRejected

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Waitlist entry already rejected",
      "long_message": "The waitlist entry has already been rejected.",
      "code": "waitlist_entry_already_rejected"
    }
  ]
}
```

### WaitlistEntryLockedError

filename: Status Code: 409
```json
{
  "errors": [
    {
      "message": "Waitlist entry is locked",
      "long_message": "This waitlist entry is locked and cannot be modified at this time. Please try again later.",
      "code": "waitlist_entry_locked"
    }
  ]
}
```

## Webhooks

### SvixAppAlreadyExists

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Only one Svix app is allowed per instance.",
      "long_message": "Only one Svix app is allowed per instance.",
      "code": "svix_app_exists"
    }
  ]
}
```

### SvixAppCreateError

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "Svix app creation failed",
      "long_message": "Could not create a Svix app with name  at this time. Please contact us if this error persists.",
      "code": "svix_app_create_error"
    }
  ]
}
```

### SvixAppMissing

filename: Status Code: 400
```json
{
  "errors": [
    {
      "message": "No Svix apps are associated with the current instance.",
      "long_message": "No Svix apps are associated with the current instance.",
      "code": "svix_app_missing"
    }
  ]
}
```

---

## Sitemap

[Overview of all docs pages](https://clerk.com/docs/llms.txt)