> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dakota.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Errors

> HTTP status codes, error types, and RFC 9457 Problem Details responses

The Dakota API uses [RFC 9457 Problem Details](https://www.rfc-editor.org/rfc/rfc9457.html) for all error responses. This standardized format provides machine-readable error types, human-readable descriptions, and actionable details to help you handle errors programmatically.

## Error Response Format

All errors return a JSON response with the `application/problem+json` content type:

```json theme={null}
{
  "type": "not-found",
  "title": "Customer Not Found",
  "status": 404,
  "detail": "Customer cst_2abc123 was not found in your organization.",
  "instance": "/customers/cst_2abc123",
  "request_id": "req_7f3a8b2c"
}
```

### Response Fields

| Field        | Type         | Required | Description                                                                      |
| ------------ | ------------ | -------- | -------------------------------------------------------------------------------- |
| `type`       | string       | Yes      | Machine-readable error type identifier.                                          |
| `title`      | string       | Yes      | Short, human-readable summary. Stable across occurrences of the same error type. |
| `status`     | integer      | Yes      | HTTP status code for this occurrence.                                            |
| `detail`     | string       | No       | Human-readable explanation specific to this occurrence.                          |
| `instance`   | string (URI) | No       | The request path that triggered this error.                                      |
| `request_id` | string       | No       | Unique request identifier. **Include this when contacting support.**             |
| `errors`     | array        | No       | Field-level validation errors (present only for validation failures).            |

### Validation Errors

When a request fails validation, the response includes an `errors` array with field-level details:

```json theme={null}
{
  "type": "validation-error",
  "title": "Validation Error",
  "status": 400,
  "detail": "One or more fields failed validation.",
  "instance": "/customers",
  "request_id": "req_8d4b2e1f",
  "errors": [
    {
      "field": "bank_account.routing_number",
      "message": "Routing number must be exactly 9 digits",
      "code": "invalid_format"
    },
    {
      "field": "email",
      "message": "Invalid email address format",
      "code": "invalid_format"
    }
  ]
}
```

**Validation Error Fields:**

| Field     | Type   | Required | Description                                                                            |
| --------- | ------ | -------- | -------------------------------------------------------------------------------------- |
| `field`   | string | Yes      | Field path using dot notation for nested fields (e.g., `bank_account.routing_number`). |
| `message` | string | Yes      | Human-readable description of the field error.                                         |
| `code`    | string | No       | Machine-readable error code for this specific field.                                   |

***

## HTTP Status Codes

| Status Code | Category     | Description                                      |
| ----------- | ------------ | ------------------------------------------------ |
| `200`       | Success      | Request completed successfully                   |
| `201`       | Success      | Resource created successfully                    |
| `204`       | Success      | Request succeeded with no response body          |
| `400`       | Client Error | Invalid request parameters, body, or identifiers |
| `401`       | Client Error | Missing or invalid authentication credentials    |
| `403`       | Client Error | Valid credentials but insufficient permissions   |
| `404`       | Client Error | Resource does not exist                          |
| `409`       | Client Error | Resource conflict or state conflict              |
| `413`       | Client Error | Request payload exceeds maximum allowed size     |
| `422`       | Client Error | Request blocked due to compliance restrictions   |
| `429`       | Client Error | Rate limit exceeded                              |
| `500`       | Server Error | Internal server error                            |
| `501`       | Server Error | Endpoint not implemented                         |
| `502`       | Server Error | Upstream provider error                          |
| `503`       | Server Error | Service temporarily unavailable                  |

***

## Error Types Reference

Each error type has a unique URI that identifies the problem category. The `type` field in every error response links directly to the corresponding section below.

### Client Errors (4xx)

<AccordionGroup>
  <Accordion title="validation-error" id="validation-error">
    **HTTP Status:** `400 Bad Request`

    **Description:** One or more request fields failed validation. Check the `errors` array for specific field-level details.

    **Example Response:**

    ```json theme={null}
    {
      "type": "validation-error",
      "title": "Validation Error",
      "status": 400,
      "detail": "One or more fields failed validation.",
      "instance": "/accounts/onramp",
      "request_id": "req_abc123",
      "errors": [
        {
          "field": "capabilities",
          "message": "capabilities is required",
          "code": "required"
        }
      ]
    }
    ```

    **Common Causes:**

    * Missing required fields in the request body
    * Invalid field format (e.g., malformed email, invalid phone number)
    * Invalid enum values
    * Field value out of allowed range

    **Resolution:** Review the `errors` array and correct each field according to the API specification.
  </Accordion>

  <Accordion title="invalid-request" id="invalid-request">
    **HTTP Status:** `400 Bad Request`

    **Description:** The request could not be processed due to malformed syntax or invalid content.

    **Example Response:**

    ```json theme={null}
    {
      "type": "invalid-request",
      "title": "Invalid Request",
      "status": 400,
      "detail": "Request body must be valid JSON.",
      "instance": "/customers",
      "request_id": "req_def456"
    }
    ```

    **Common Causes:**

    * Malformed JSON in request body
    * Invalid Content-Type header
    * Missing required headers
    * Request body too large

    **Resolution:** Verify that your request body is valid JSON and includes all required headers.
  </Accordion>

  <Accordion title="invalid-identifier" id="invalid-identifier">
    **HTTP Status:** `400 Bad Request`

    **Description:** One or more resource identifiers in the request are malformed or invalid.

    **Example Response:**

    ```json theme={null}
    {
      "type": "invalid-identifier",
      "title": "Invalid Identifier",
      "status": 400,
      "detail": "The identifier 'invalid-id' is not a valid KSUID.",
      "instance": "/customers/invalid-id",
      "request_id": "req_ghi789"
    }
    ```

    **Common Causes:**

    * Invalid KSUID format in path or query parameters
    * Using an identifier from a different resource type
    * Malformed UUID or prefixed ID

    **Resolution:** Ensure all identifiers are valid KSUIDs (27-character base62 strings) obtained from previous API responses.
  </Accordion>

  <Accordion title="insufficient-balance" id="insufficient-balance">
    **HTTP Status:** `400 Bad Request`

    **Description:** The operation cannot be completed due to insufficient balance in the source account or wallet.

    **Example Response:**

    ```json theme={null}
    {
      "type": "insufficient-balance",
      "title": "Insufficient Balance",
      "status": 400,
      "detail": "Wallet has insufficient USDC balance for this transaction.",
      "instance": "/transactions",
      "request_id": "req_jkl012"
    }
    ```

    **Common Causes:**

    * Attempting to transfer more than available balance
    * Balance reserved for pending transactions
    * Network fees not accounted for in available balance

    **Resolution:** Check the account or wallet balance before initiating the transaction.
  </Accordion>

  <Accordion title="limit-reached" id="limit-reached">
    **HTTP Status:** `400 Bad Request`

    **Description:** A configured resource limit has been reached for your organization.

    **Example Response:**

    ```json theme={null}
    {
      "type": "limit-reached",
      "title": "Limit Reached",
      "status": 400,
      "detail": "Maximum number of API keys (10) has been reached.",
      "instance": "/api-keys",
      "request_id": "req_mno345"
    }
    ```

    **Common Causes:**

    * Maximum API keys created
    * Maximum webhook targets configured
    * Resource quota exceeded

    **Resolution:** Delete unused resources or contact support to increase limits.
  </Accordion>

  <Accordion title="multiple-clients" id="multiple-clients">
    **HTTP Status:** `400 Bad Request`

    **Description:** The authenticated user has access to multiple clients. You must specify which client to use.

    **Example Response:**

    ```json theme={null}
    {
      "type": "multiple-clients",
      "title": "Multiple Clients",
      "status": 400,
      "detail": "Multiple clients are available; select an active client.",
      "instance": "/customers",
      "request_id": "req_pqr678"
    }
    ```

    **Resolution:** Include the appropriate client context in your request or select a default client in the dashboard.
  </Accordion>

  <Accordion title="authentication-error" id="authentication-error">
    **HTTP Status:** `401 Unauthorized`

    **Description:** Authentication credentials are missing, invalid, or expired.

    **Example Response:**

    ```json theme={null}
    {
      "type": "authentication-error",
      "title": "Authentication Required",
      "status": 401,
      "detail": "Missing or invalid authentication credentials.",
      "instance": "/customers",
      "request_id": "req_stu901"
    }
    ```

    **Common Causes:**

    * Missing `x-api-key` header
    * Invalid or revoked API key
    * Expired application token
    * Malformed authentication header

    **Resolution:** Verify your API key is correct and active. Check that the `x-api-key` header is properly formatted.
  </Accordion>

  <Accordion title="forbidden" id="forbidden">
    **HTTP Status:** `403 Forbidden`

    **Description:** Your credentials are valid but you do not have permission to perform this action.

    **Example Response:**

    ```json theme={null}
    {
      "type": "forbidden",
      "title": "Forbidden",
      "status": 403,
      "detail": "You do not have permission to access this customer.",
      "instance": "/customers/cst_xyz789",
      "request_id": "req_vwx234"
    }
    ```

    **Common Causes:**

    * Accessing a resource belonging to another organization
    * API key lacks required scopes
    * User role insufficient for the operation
    * Resource access restricted by policy

    **Resolution:** Verify you have the necessary permissions. Contact your administrator to request access.
  </Accordion>

  <Accordion title="state-restricted-rd" id="state-restricted-rd">
    **HTTP Status:** `403 Forbidden`

    **Description:** The requested onramp or swap account would deal in **RD**, but RD is not available in the customer's US state.

    **Example Response:**

    ```json theme={null}
    {
      "type": "state-restricted-rd",
      "title": "State Restricted",
      "status": 403,
      "detail": "RD is not available in your state.",
      "instance": "/accounts",
      "request_id": "req_abc123"
    }
    ```

    **When it happens:** RD availability is geofenced by US state. A customer is blocked when any of their governing US states — a business's registered or operating address, or an individual's residential address — is on Dakota's restricted list. Restricted states are currently **FL, GA, NY, TX, WA, and LA** (subject to change). Non-US customers, and customers whose US jurisdiction is not yet resolved, are unaffected.

    **Resolution:** Use a non-RD destination stablecoin (e.g. `USDC`) for affected customers, or contact Dakota if you believe the customer's state has been resolved incorrectly.
  </Accordion>

  <Accordion title="not-found" id="not-found">
    **HTTP Status:** `404 Not Found`

    **Description:** The requested resource does not exist or has been deleted.

    **Example Response:**

    ```json theme={null}
    {
      "type": "not-found",
      "title": "Customer Not Found",
      "status": 404,
      "detail": "Customer cst_2abc123 was not found.",
      "instance": "/customers/cst_2abc123",
      "request_id": "req_yza567"
    }
    ```

    **Common Causes:**

    * Resource was deleted
    * Incorrect resource ID
    * Resource belongs to a different organization
    * Typo in the resource path

    **Resolution:** Verify the resource ID is correct. Use list endpoints to confirm the resource exists.
  </Accordion>

  <Accordion title="conflict" id="conflict">
    **HTTP Status:** `409 Conflict`

    **Description:** The request conflicts with the current state of the resource.

    **Example Response:**

    ```json theme={null}
    {
      "type": "conflict",
      "title": "Customer Conflict",
      "status": 409,
      "detail": "A customer with external_id 'ext-123' already exists.",
      "instance": "/customers",
      "request_id": "req_bcd890"
    }
    ```

    **Common Causes:**

    * Duplicate `external_id` when creating a customer
    * Duplicate name for a unique resource
    * Attempting to transition to an invalid state
    * Concurrent modification conflict

    **Resolution:** Use unique identifiers or fetch the existing resource to update it instead.
  </Accordion>

  <Accordion title="payload-too-large" id="payload-too-large">
    **HTTP Status:** `413 Payload Too Large`

    **Description:** The request payload exceeds the maximum allowed size.

    **Example Response:**

    ```json theme={null}
    {
      "type": "payload-too-large",
      "title": "Payload Too Large",
      "status": 413,
      "detail": "Request payload exceeds the maximum allowed size of 500 MB.",
      "instance": "/applications/app_123/documents",
      "request_id": "req_efg123"
    }
    ```

    **Common Causes:**

    * File upload exceeds 500 MB limit
    * Request body too large
    * Bulk operation with too many items

    **Resolution:** Reduce the payload size or split into multiple requests.
  </Accordion>

  <Accordion title="compliance-blocked" id="compliance-blocked">
    **HTTP Status:** `422 Unprocessable Entity`

    **Description:** The request cannot be completed due to compliance restrictions.

    **Example Response:**

    ```json theme={null}
    {
      "type": "compliance-blocked",
      "title": "Compliance Blocked",
      "status": 422,
      "detail": "This wallet address cannot be processed due to compliance restrictions.",
      "instance": "/transactions",
      "request_id": "req_hij456"
    }
    ```

    **Common Causes:**

    * Destination wallet address flagged by compliance screening
    * Transaction blocked by sanctions screening
    * Customer flagged for compliance review
    * Geographic restrictions

    **Resolution:** Contact support for details on the compliance block. Do not attempt to circumvent compliance controls.
  </Accordion>

  <Accordion title="rate-limited" id="rate-limited">
    **HTTP Status:** `429 Too Many Requests`

    **Description:** You have exceeded the rate limit for API requests.

    **Example Response:**

    ```json theme={null}
    {
      "type": "rate-limited",
      "title": "Rate Limited",
      "status": 429,
      "detail": "Too many requests. Please retry later.",
      "instance": "/customers",
      "request_id": "req_klm789"
    }
    ```

    **Rate Limit Headers:**

    Every response includes rate limit information:

    | Header                  | Description                                               |
    | ----------------------- | --------------------------------------------------------- |
    | `X-RateLimit-Limit`     | Maximum requests allowed in the current one-minute window |
    | `X-RateLimit-Remaining` | Requests remaining in the current window                  |
    | `X-RateLimit-Reset`     | Unix timestamp when the current window resets             |
    | `Retry-After`           | Seconds to wait before retrying (only on 429 responses)   |

    **Rate Limits by Authentication Type:**

    | Authentication    | Limit                   |
    | ----------------- | ----------------------- |
    | API Key           | 60 requests per minute  |
    | JWT (Dashboard)   | 600 requests per minute |
    | Application Token | 100 requests per hour   |
    | Unauthenticated   | 10 requests per minute  |

    **Resolution:** Implement exponential backoff and respect the `Retry-After` header.
  </Accordion>
</AccordionGroup>

### Server Errors (5xx)

<AccordionGroup>
  <Accordion title="internal-error" id="internal-error">
    **HTTP Status:** `500 Internal Server Error`

    **Description:** An unexpected error occurred on the server. The error details are sanitized for security.

    **Example Response:**

    ```json theme={null}
    {
      "type": "internal-error",
      "title": "Internal Server Error",
      "status": 500,
      "detail": "An unexpected error occurred.",
      "instance": "/customers",
      "request_id": "req_nop012"
    }
    ```

    **Resolution:** Retry with exponential backoff. If the error persists, contact support with the `request_id`.
  </Accordion>

  <Accordion title="not-implemented" id="not-implemented">
    **HTTP Status:** `501 Not Implemented`

    **Description:** The requested endpoint or feature is not yet implemented.

    **Example Response:**

    ```json theme={null}
    {
      "type": "not-implemented",
      "title": "Not Implemented",
      "status": 501,
      "detail": "This endpoint is not implemented.",
      "instance": "/some-future-endpoint",
      "request_id": "req_qrs345"
    }
    ```

    **Resolution:** Check the API documentation for available endpoints. Contact support if you believe this is an error.
  </Accordion>

  <Accordion title="provider-error" id="provider-error">
    **HTTP Status:** `502 Bad Gateway`

    **Description:** An upstream provider returned an error.

    **Example Response:**

    ```json theme={null}
    {
      "type": "provider-error",
      "title": "Provider Error",
      "status": 502,
      "detail": "An upstream provider returned an error.",
      "instance": "/transactions",
      "request_id": "req_tuv678"
    }
    ```

    **Resolution:** Retry with exponential backoff. These errors are typically transient.
  </Accordion>

  <Accordion title="service-unavailable" id="service-unavailable">
    **HTTP Status:** `503 Service Unavailable`

    **Description:** The service is temporarily unavailable, typically during maintenance.

    **Example Response:**

    ```json theme={null}
    {
      "type": "service-unavailable",
      "title": "Service Unavailable",
      "status": 503,
      "detail": "Service is temporarily unavailable.",
      "instance": "/customers",
      "request_id": "req_wxy901"
    }
    ```

    **Resolution:** Retry with exponential backoff. Check our status page for maintenance announcements.
  </Accordion>
</AccordionGroup>

***

## Error Handling Best Practices

### Basic Error Handler

```javascript theme={null}
const response = await fetch('https://api.platform.dakota.xyz/customers', {
  headers: { 'x-api-key': apiKey }
});

if (!response.ok) {
  const problem = await response.json();

  // Log the request_id for support tickets
  console.error(`Error [${problem.request_id}]: ${problem.title}`);

  switch (problem.status) {
    case 400:
      // Handle validation errors
      if (problem.errors) {
        problem.errors.forEach(err => {
          console.log(`Field '${err.field}': ${err.message}`);
        });
      }
      break;
    case 401:
      console.log('Check your API key');
      break;
    case 404:
      console.log('Resource not found');
      break;
    case 429:
      const retryAfter = response.headers.get('Retry-After') || 60;
      console.log(`Rate limited. Retry after ${retryAfter} seconds`);
      break;
    default:
      console.error(`Error: ${problem.detail}`);
  }
}
```

### Retry Logic with Exponential Backoff

For transient errors (5xx, rate limits), implement exponential backoff:

<CodeGroup>
  ```javascript JavaScript theme={null}
  async function fetchWithRetry(url, options, maxRetries = 3) {
    const retryableStatuses = [429, 500, 502, 503];

    for (let attempt = 0; attempt <= maxRetries; attempt++) {
      try {
        const response = await fetch(url, options);

        if (response.ok) {
          return response.json();
        }

        const problem = await response.json();

        // Check if error is retryable
        if (retryableStatuses.includes(problem.status) && attempt < maxRetries) {
          let delay;

          if (problem.status === 429) {
            // Use Retry-After header if available
            delay = (parseInt(response.headers.get('Retry-After')) || 60) * 1000;
          } else {
            // Exponential backoff: 1s, 2s, 4s
            delay = Math.pow(2, attempt) * 1000;
          }

          console.log(`Retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
          await new Promise(r => setTimeout(r, delay));
          continue;
        }

        // Non-retryable error
        throw new Error(`API Error [${problem.request_id}]: ${problem.title} - ${problem.detail}`);

      } catch (networkError) {
        // Network errors are retryable
        if (attempt < maxRetries) {
          const delay = Math.pow(2, attempt) * 1000;
          console.log(`Network error, retrying in ${delay}ms`);
          await new Promise(r => setTimeout(r, delay));
          continue;
        }
        throw networkError;
      }
    }
  }

  // Usage
  try {
    const customer = await fetchWithRetry(
      'https://api.platform.dakota.xyz/customers/cst_123',
      { headers: { 'x-api-key': apiKey } }
    );
    console.log('Customer:', customer);
  } catch (error) {
    console.error('Request failed after retries:', error.message);
  }
  ```

  ```python Python theme={null}
  import time
  import requests
  from typing import Dict, Any

  def fetch_with_retry(
      url: str,
      headers: Dict[str, str],
      max_retries: int = 3
  ) -> Dict[str, Any]:
      """Make API request with exponential backoff retry logic."""

      retryable_statuses = [429, 500, 502, 503]

      for attempt in range(max_retries + 1):
          try:
              response = requests.get(url, headers=headers)

              if response.ok:
                  return response.json()

              problem = response.json()
              status = problem.get('status', response.status_code)

              # Check if error is retryable
              if status in retryable_statuses and attempt < max_retries:
                  if status == 429:
                      # Use Retry-After header if available
                      delay = int(response.headers.get('Retry-After', 60))
                  else:
                      # Exponential backoff: 1s, 2s, 4s
                      delay = 2 ** attempt

                  print(f"Retrying in {delay}s (attempt {attempt + 1}/{max_retries})")
                  time.sleep(delay)
                  continue

              # Non-retryable error
              request_id = problem.get('request_id', 'unknown')
              raise Exception(
                  f"API Error [{request_id}]: {problem.get('title')} - {problem.get('detail')}"
              )

          except requests.exceptions.RequestException as e:
              # Network errors are retryable
              if attempt < max_retries:
                  delay = 2 ** attempt
                  print(f"Network error, retrying in {delay}s")
                  time.sleep(delay)
                  continue
              raise

  # Usage
  try:
      customer = fetch_with_retry(
          'https://api.platform.dakota.xyz/customers/cst_123',
          headers={'x-api-key': api_key}
      )
      print('Customer:', customer)
  except Exception as e:
      print(f'Request failed after retries: {e}')
  ```

  ```go Go theme={null}
  package main

  import (
      "encoding/json"
      "fmt"
      "net/http"
      "strconv"
      "time"
  )

  type ProblemDetails struct {
      Type      string `json:"type"`
      Title     string `json:"title"`
      Status    int    `json:"status"`
      Detail    string `json:"detail"`
      RequestID string `json:"request_id"`
  }

  func fetchWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
      retryableStatuses := map[int]bool{429: true, 500: true, 502: true, 503: true}

      for attempt := 0; attempt <= maxRetries; attempt++ {
          req, _ := http.NewRequest("GET", url, nil)
          req.Header.Set("x-api-key", apiKey)

          client := &http.Client{Timeout: 30 * time.Second}
          resp, err := client.Do(req)

          if err != nil {
              // Network error - retry
              if attempt < maxRetries {
                  delay := time.Duration(1<<attempt) * time.Second
                  fmt.Printf("Network error, retrying in %v\n", delay)
                  time.Sleep(delay)
                  continue
              }
              return nil, err
          }
          defer resp.Body.Close()

          if resp.StatusCode >= 200 && resp.StatusCode < 300 {
              var result []byte
              json.NewDecoder(resp.Body).Decode(&result)
              return result, nil
          }

          var problem ProblemDetails
          json.NewDecoder(resp.Body).Decode(&problem)

          if retryableStatuses[problem.Status] && attempt < maxRetries {
              var delay time.Duration
              if problem.Status == 429 {
                  retryAfter := resp.Header.Get("Retry-After")
                  seconds, _ := strconv.Atoi(retryAfter)
                  if seconds == 0 {
                      seconds = 60
                  }
                  delay = time.Duration(seconds) * time.Second
              } else {
                  delay = time.Duration(1<<attempt) * time.Second
              }
              fmt.Printf("Retrying in %v (attempt %d/%d)\n", delay, attempt+1, maxRetries)
              time.Sleep(delay)
              continue
          }

          return nil, fmt.Errorf("API Error [%s]: %s - %s",
              problem.RequestID, problem.Title, problem.Detail)
      }

      return nil, fmt.Errorf("max retries exceeded")
  }
  ```
</CodeGroup>

### Idempotency for Safe Retries

For POST requests, always include the `x-idempotency-key` header to safely retry failed requests:

```bash theme={null}
curl -X POST https://api.platform.dakota.xyz/customers \
  -H "x-api-key: YOUR_API_KEY" \
  -H "x-idempotency-key: unique-request-id-123" \
  -H "Content-Type: application/json" \
  -d '{"customer_type": "business", "name": "Acme Corp"}'
```

<Warning>
  **Important:** The idempotency key must be unique per logical operation. Reusing a key with different request parameters may return the cached response from the original request.
</Warning>

***

## Troubleshooting

### Getting Help

When contacting support about an error:

1. **Always include the `request_id`** from the error response
2. Provide the full error response body
3. Include the request method, path, and relevant headers (redact the API key)
4. Describe what you expected vs. what happened

### Common Issues

<AccordionGroup>
  <Accordion title="401 Unauthorized on every request">
    **Symptoms:** All requests return authentication errors.

    **Checklist:**

    1. Verify the `x-api-key` header is included (not `X-Api-Key` or `api-key`)
    2. Check that the API key is not expired or revoked
    3. Ensure there are no extra spaces or newlines in the key
    4. Verify you're using the correct environment (sandbox vs production)
  </Accordion>

  <Accordion title="400 Validation Error with no details">
    **Symptoms:** Getting validation errors without clear field information.

    **Checklist:**

    1. Check the `errors` array in the response for field-level details
    2. Verify your `Content-Type` header is `application/json`
    3. Ensure the request body is valid JSON
    4. Compare your request against the OpenAPI specification
  </Accordion>

  <Accordion title="429 Rate Limited frequently">
    **Symptoms:** Hitting rate limits during normal operation.

    **Checklist:**

    1. Check `X-RateLimit-Remaining` header to monitor usage
    2. Implement request batching where possible
    3. Add caching for frequently accessed resources
    4. Consider using webhooks instead of polling
  </Accordion>
</AccordionGroup>

For detailed troubleshooting, see our [Troubleshooting Guide](/documentation/authentication/troubleshooting).