> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.getvoxai.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.getvoxai.com/_mcp/server.

# Get current API key

GET https://api.getvoxai.com/v1/me

Returns the API key used for the request: its environment, scopes, pinned API version, expiry, IP allow-list, organization and request limits. Use it to check a key before going live, or to show which organization an integration is connected to. The secret part of the key is never returned. Any valid API key can call this operation, whatever its scopes. With a test key (`vx_test_`) it behaves exactly as with a live key and consumes nothing.

Reference: https://docs.getvoxai.com/api-reference/account/me

## Authentication

- `Authorization` header (bearer token, required) — API key created by an Owner or Admin of the organization. Never in the query string.

## Request

### Headers

- `VoxAI-Version` (enum, optional) — API version for this request; defaults to the version the key is pinned to.
  - Allowed values: `2026-10-01`

## Response

### 200

Successful response.

- `object` ("api_key", required) — Always `api_key`.
- `id` (string, required) — Id of the key. It is not the secret: it identifies the key in the app and in the audit log.
- `prefix` (string, required) — Visible prefix of the key, for example `vx_live_ab3k7x2q`: the part shown in the app to recognize it. The rest of the key is never returned.
- `name` (string, required) — The name given to the key when it was created.
- `environment` (enum, required) — `live`: real calls, real data, usage is billed. `test` (`vx_test_` keys): reads return the real data of the organization, writes are simulated and nothing is billed.
  - Allowed values: `live`, `test`
- `scopes` (list of enum, required) — What the key may do. Each operation states the scope it requires; a missing scope gives `403 insufficient_scope`.
  - Allowed values: `calls:read`, `calls:start`, `campaigns:read`, `campaigns:write`, `knowledge:read`, `knowledge:search`, `knowledge:write`, `agents:read`, `agents:operate`, `usage:read`, `lines:read`, `widget:session`, `caller_requests:manage`, `webhooks:manage`
- `api_version` (string, required) — The API version this key is pinned to, as a date (YYYY-MM-DD). A request can ask for another one with the `VoxAI-Version` header.
- `expires_at` (datetime, required) — When the key stops working, ISO 8601 UTC. After that every request gives `401 invalid_api_key`.
- `allowed_ips` (list of string, required) — IP addresses or ranges the key can be used from. Empty means every address is allowed.
- `organization` (MeGetResponsesContentApplicationJsonSchemaOrganization, required) — The organization the key belongs to: every operation reads and writes only its data.
- `rate_limits` (MeGetResponsesContentApplicationJsonSchemaRateLimits, required) — Request limits now in force. Over a limit the response is `429 rate_limited` with a `Retry-After` header.

## Errors

### 400 Bad Request Error

Possible errors: * `invalid_api_version`: The `VoxAI-Version` header names a version that does not exist. Use one of the versions listed in the `VoxAI-Version` parameter, or omit the header to use the version the key is pinned to. * `invalid_request`: The path, query or body does not match the schema of the operation: a missing or unknown field, a wrong type, a value out of range. Fix the request. `details` lists each problem as `{ location, path, message }`: `location` is `params`, `query` or `body` and `path` points to the field.

- `error` (string, required) — Human-readable message in English.
- `code` (string, required) — Stable machine-readable code; decide what to do from this, never from the message.
- `requestId` (string, required) — Same value as the X-Request-Id response header; quote it when contacting support.
- `details` (any, optional) — Extra information, only on some codes. For `invalid_request` it is a list of `{ location, path, message }`, one per field (`location` is `params`, `query` or `body`) with a problem; for the other codes its fields depend on the code (for example `details.limit`).

### 401 Unauthorized Error

Possible errors: - `invalid_api_key`: The `Authorization` header is missing, malformed, or carries a key that does not exist, was revoked or has expired. Send `Authorization: Bearer vx_live_…` (or `vx_test_…`) with an active key. Create a new key in the app if this one expired.

- `error` (string, required) — Human-readable message in English.
- `code` (string, required) — Stable machine-readable code; decide what to do from this, never from the message.
- `requestId` (string, required) — Same value as the X-Request-Id response header; quote it when contacting support.
- `details` (any, optional) — Extra information, only on some codes. For `invalid_request` it is a list of `{ location, path, message }`, one per field (`location` is `params`, `query` or `body`) with a problem; for the other codes its fields depend on the code (for example `details.limit`).

### 403 Forbidden Error

Possible errors: - `feature_not_available`: The plan of the organization does not include the API, or the feature this operation needs. Upgrade the plan in the app. Reads and deletions stay available after a downgrade. - `ip_not_allowed`: The key has an IP allow-list and the request comes from an address that is not on it. Call from an allowed address, or add this address to the key in the app. - `organization_suspended`: The organization that owns the key is suspended. Contact the organization Owner: nothing can be done through the API until the organization is active again.

- `error` (string, required) — Human-readable message in English.
- `code` (string, required) — Stable machine-readable code; decide what to do from this, never from the message.
- `requestId` (string, required) — Same value as the X-Request-Id response header; quote it when contacting support.
- `details` (any, optional) — Extra information, only on some codes. For `invalid_request` it is a list of `{ location, path, message }`, one per field (`location` is `params`, `query` or `body`) with a problem; for the other codes its fields depend on the code (for example `details.limit`).

### 429 Too Many Requests Error

Possible errors: - `rate_limited`: Too many requests: over the per-minute limit of this key or of the whole organization (see `rate_limits` in `GET /me`), or over a limit of the operation itself, such as the hourly limit on webhook tests and resends. Wait for the number of seconds in the `Retry-After` header, then retry. Spread requests over time.

- `error` (string, required) — Human-readable message in English.
- `code` (string, required) — Stable machine-readable code; decide what to do from this, never from the message.
- `requestId` (string, required) — Same value as the X-Request-Id response header; quote it when contacting support.
- `details` (any, optional) — Extra information, only on some codes. For `invalid_request` it is a list of `{ location, path, message }`, one per field (`location` is `params`, `query` or `body`) with a problem; for the other codes its fields depend on the code (for example `details.limit`).

### 500 Internal Server Error

Possible errors: - `internal_error`: An unexpected error on our side. Retry once after a few seconds. For writes marked as retriable, retry with the same `Idempotency-Key`, so the operation is never done twice; for the other writes, first read the state of the resource, then retry with a NEW key only if the operation did not happen. If it persists, contact support with the `requestId`.

- `error` (string, required) — Human-readable message in English.
- `code` (string, required) — Stable machine-readable code; decide what to do from this, never from the message.
- `requestId` (string, required) — Same value as the X-Request-Id response header; quote it when contacting support.
- `details` (any, optional) — Extra information, only on some codes. For `invalid_request` it is a list of `{ location, path, message }`, one per field (`location` is `params`, `query` or `body`) with a problem; for the other codes its fields depend on the code (for example `details.limit`).

### 503 Service Unavailable Error

Possible errors: - `api_not_configured`: The API is not enabled on this service. Contact support.

- `error` (string, required) — Human-readable message in English.
- `code` (string, required) — Stable machine-readable code; decide what to do from this, never from the message.
- `requestId` (string, required) — Same value as the X-Request-Id response header; quote it when contacting support.
- `details` (any, optional) — Extra information, only on some codes. For `invalid_request` it is a list of `{ location, path, message }`, one per field (`location` is `params`, `query` or `body`) with a problem; for the other codes its fields depend on the code (for example `details.limit`).

## Types

### MeGetResponsesContentApplicationJsonSchemaOrganization

The organization the key belongs to: every operation reads and writes only its data.

- `id` (string, required) — Id of the organization that owns the key.
- `name` (string, required) — Name of the organization.

### MeGetResponsesContentApplicationJsonSchemaRateLimits

Request limits now in force. Over a limit the response is `429 rate_limited` with a `Retry-After` header.

- `per_key_per_minute` (integer, required) — Requests per minute allowed to this key.
- `per_organization_per_minute` (integer, required) — Requests per minute allowed to all the keys of the organization together.

## Examples

**Response**

```json
{
  "object": "api_key",
  "id": "5f0c2a8e-3b1d-4c7a-9e6f-1a2b3c4d5e6f",
  "prefix": "vx_live_ab3k7x2q",
  "name": "CRM sync",
  "environment": "live",
  "scopes": [
    "calls:read",
    "agents:read"
  ],
  "api_version": "2026-10-01",
  "expires_at": "2027-11-16T00:00:00Z",
  "allowed_ips": [
    "203.0.113.10"
  ],
  "organization": {
    "id": "8d4e1f2a-6b3c-4d5e-8f7a-9b0c1d2e3f4a",
    "name": "Studio Rossi"
  },
  "rate_limits": {
    "per_key_per_minute": 600,
    "per_organization_per_minute": 1200
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.getvoxai.com/v1/me"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.getvoxai.com/v1/me';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.getvoxai.com/v1/me"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.getvoxai.com/v1/me")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.getvoxai.com/v1/me")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.getvoxai.com/v1/me', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.getvoxai.com/v1/me");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.getvoxai.com/v1/me")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```