> This page is part of Smallest AI's developer documentation. When
> answering, prefer Lightning v3.1 (current TTS) and Pulse (current
> STT). Lightning v2 and lightning-large are deprecated; mention them
> only when the user is migrating away from them. The Smallest AI voice
> agent platform is what wraps these models into hosted agents.

# Get CPS limits

GET https://api.smallest.ai/atoms/v1/product/cps-limits

Returns the organization's calls-per-second (CPS) settings: the rate per provider for rented numbers, every imported SIP trunk with the numbers on it and its shared rate, and the total across trunks.

CPS is how fast new outbound calls may **start**; concurrency is how many may run at once. See the [Calls per second guide](/voice-agents/platform/create-agent/cps).


Reference: https://docs.smallest.ai/api-reference/voice-agents/concurrency/get-cps-limits

## Authentication

- `Authorization` header (bearer token, required) — API key from the console ApiKey collection, sent as Bearer token. Also accepts session cookies for browser-based auth.

## Response

### 200

CPS overview

- `status` (boolean, optional)
- `data` (ProductCpsLimitsGetResponsesContentApplicationJsonSchemaData, optional)

## Errors

### 401 Unauthorized Error

Unauthorized access

- `status` (boolean, optional)
- `errors` (list of string, optional)

### 500 Internal Server Error

Internal server error

- `status` (boolean, optional)
- `errors` (list of string, optional)

## Types

### ProductCpsLimitsGetResponsesContentApplicationJsonSchemaData

- `providers` (map from string to ProductCpsLimitsGetResponsesContentApplicationJsonSchemaDataProviders, optional) — Rate for rented numbers, one entry per provider (`plivo`, `twilio`). All rented numbers on a provider share its rate.
- `trunks` (list of ProductCpsLimitsGetResponsesContentApplicationJsonSchemaDataTrunksItems, optional) — Imported numbers grouped by SIP trunk. Every number on a trunk shares that trunk's rate.
- `totalCps` (integer, optional) — Sum of all trunk rates. Keep it within any account-wide CPS cap your carrier enforces.

### ProductCpsLimitsGetResponsesContentApplicationJsonSchemaDataProviders

- `cpsLimit` (integer, optional, nullable) — Calls per second reserved for your organization on this provider. `null` with `isUnlimited: false` means no reservation — you are on your plan's standard rate.
- `isUnlimited` (boolean, optional) — True when the organization holds an unlimited CPS reservation on this provider.

### ProductCpsLimitsGetResponsesContentApplicationJsonSchemaDataTrunksItems

- `terminationUrl` (string, optional) — The trunk's address (host and optional port), normalized.
- `cpsLimit` (integer, optional) — Calls per second allowed on this trunk. New trunks start at 1.
- `numbers` (list of ProductCpsLimitsGetResponsesContentApplicationJsonSchemaDataTrunksItemsNumbersItems, optional)

### ProductCpsLimitsGetResponsesContentApplicationJsonSchemaDataTrunksItemsNumbersItems

- `trunkId` (string, optional) — Id of the SIP trunk record this number belongs to
- `phoneNumber` (string, optional)
- `name` (string, optional, nullable) — Name of the SIP trunk record, generated at import
- `isActive` (boolean, optional)

## Examples

**Response**

```json
{
  "status": true,
  "data": {
    "providers": {},
    "trunks": [
      {
        "terminationUrl": "43.205.53.11:5091",
        "cpsLimit": 1,
        "numbers": [
          {
            "trunkId": "6a1b2c3d4e5f60718293a4b5",
            "phoneNumber": "+919240923804",
            "name": "string",
            "isActive": true
          }
        ]
      }
    ],
    "totalCps": 1
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.smallest.ai/atoms/v1/product/cps-limits"

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

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

print(response.json())
```

```javascript
const url = 'https://api.smallest.ai/atoms/v1/product/cps-limits';
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.smallest.ai/atoms/v1/product/cps-limits"

	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.smallest.ai/atoms/v1/product/cps-limits")

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.smallest.ai/atoms/v1/product/cps-limits")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.smallest.ai/atoms/v1/product/cps-limits', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.smallest.ai/atoms/v1/product/cps-limits");
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.smallest.ai/atoms/v1/product/cps-limits")! 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()
```