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

# Verify API Key

> Verify that your API key is valid and check rate limit status

Use this endpoint to verify that your API key is valid and check your current rate limit status. This is useful for debugging authentication issues and monitoring your API usage.

## Quick Test

The verify endpoint is perfect for:

* Testing new API keys
* Checking rate limit status
* Debugging authentication issues
* Monitoring API permissions

## Example Usage

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET "https://api.nolano.ai/verify" \
    -H "Authorization: Bearer ak_your_api_key_here" \
    -H "Content-Type: application/json"
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      "https://api.nolano.ai/verify",
      headers={
          "Authorization": "Bearer ak_your_api_key_here",
          "Content-Type": "application/json"
      }
  )

  if response.status_code == 200:
      data = response.json()
      print(f"✅ API key is valid")
      print(f"Permissions: {data['apiKey']['permissions']}")
      print(f"Rate limit: {data['rateLimit']['remaining']}/{data['rateLimit']['limit']}")
  else:
      print(f"❌ Authentication failed: {response.status_code}")
      print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api.nolano.ai/verify', {
    headers: {
      'Authorization': 'Bearer ak_your_api_key_here',
      'Content-Type': 'application/json'
    }
  });

  const data = await response.json();

  if (response.ok) {
    console.log('✅ API key is valid');
    console.log('Permissions:', data.apiKey.permissions);
    console.log(`Rate limit: ${data.rateLimit.remaining}/${data.rateLimit.limit}`);
  } else {
    console.log('❌ Authentication failed:', response.status);
    console.log(data);
  }
  ```
</CodeGroup>

## Response Fields

The verify endpoint returns detailed information about your API key:

* **success**: Boolean indicating if the key is valid
* **message**: Human-readable status message
* **timestamp**: Server timestamp of the verification
* **apiKey.permissions**: Array of permissions for your key
* **rateLimit**: Current rate limit status including remaining requests

## Rate Limit Information

The response includes your current rate limit status:

```json Example Rate Limit Response theme={null}
{
  "rateLimit": {
    "limit": "1000",
    "remaining": "999", 
    "resetTime": "1755044460000"
  }
}
```

Use this information to avoid hitting rate limits in your applications.


## OpenAPI

````yaml GET /verify
openapi: 3.1.0
info:
  title: Nolano Time Series Forecasting API
  description: >-
    Enterprise-grade Time Series Foundation Models for forecasting and anomaly
    detection with secure authentication, robust key management, and AWS-powered
    reliability.
  version: 1.0.0
  contact:
    name: Nolano Support
    email: hello@nolano.com
    url: https://nolano.ai
  license:
    name: Proprietary
    url: https://nolano.ai/terms
servers:
  - url: https://api.nolano.ai
    description: Production API server
security:
  - bearerAuth: []
tags:
  - name: Authentication
    description: API key verification and authentication
  - name: Forecasting
    description: Time series forecasting endpoints
paths:
  /verify:
    get:
      tags:
        - Authentication
      summary: Verify API Key
      description: Verify that your API key is valid and check rate limit status
      operationId: verifyApiKey
      responses:
        '200':
          description: API key is valid
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/VerifyResponse'
        '401':
          description: Invalid or missing API key
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
      security:
        - bearerAuth: []
components:
  schemas:
    VerifyResponse:
      type: object
      required:
        - success
        - message
        - timestamp
      properties:
        success:
          type: boolean
          description: Whether the API key is valid
          example: true
        message:
          type: string
          description: Human-readable status message
          example: API key is valid and working correctly
        timestamp:
          type: string
          format: date-time
          description: Server timestamp
          example: '2025-01-17T00:20:24.435Z'
        apiKey:
          type: object
          properties:
            permissions:
              type: array
              items:
                type: string
              description: API key permissions
              example:
                - read
        rateLimit:
          type: object
          properties:
            limit:
              type: string
              description: Request limit per period
              example: '1000'
            remaining:
              type: string
              description: Remaining requests in current period
              example: '999'
            resetTime:
              type: string
              description: Unix timestamp when limits reset
              example: '1755044460000'
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              description: Machine-readable error code
              enum:
                - UNAUTHORIZED
                - INVALID_REQUEST
                - DATA_VALIDATION_ERROR
                - RATE_LIMIT_EXCEEDED
                - INTERNAL_ERROR
              example: INVALID_REQUEST
            message:
              type: string
              description: Human-readable error message
              example: Validation failed for one or more fields
            details:
              type: object
              description: Additional error context and debugging information
              additionalProperties: true
              example:
                field: forecast_horizon
                issue: Must be between 1 and 100
                provided: 150
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: ak_[64_character_hex_string]
      description: API key authentication. Include your API key with 'Bearer' prefix.

````