> 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.

# Attempt cohort analysis

GET https://api.smallest.ai/atoms/v1/analytics/attempt-cohort

Returns cohort analysis of call attempt numbers, showing how pickup rate changes across the 1st, 2nd, 3rd (etc.) attempts to reach the same number, including cumulative rates and marginal gain per additional attempt.

Reference: https://docs.smallest.ai/voice-agents/api-reference/analytics/get-attempt-cohort

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: atoms
  version: 1.0.0
paths:
  /analytics/attempt-cohort:
    get:
      operationId: get-attempt-cohort
      summary: Attempt cohort analysis
      description: >-
        Returns cohort analysis of call attempt numbers, showing how pickup rate
        changes across the 1st, 2nd, 3rd (etc.) attempts to reach the same
        number, including cumulative rates and marginal gain per additional
        attempt.
      tags:
        - analytics
      parameters:
        - name: agentId
          in: query
          description: Comma-separated agent IDs to filter results
          required: false
          schema:
            type: string
        - name: campaignId
          in: query
          description: Campaign ID to filter results
          required: false
          schema:
            type: string
        - name: callType
          in: query
          description: Type of call to filter (e.g. `inbound`, `outbound`)
          required: false
          schema:
            type: string
        - name: dateFrom
          in: query
          description: Start of date range (ISO 8601)
          required: false
          schema:
            type: string
            format: date-time
        - name: dateTo
          in: query
          description: End of date range (ISO 8601)
          required: false
          schema:
            type: string
            format: date-time
        - name: Authorization
          in: header
          description: >-
            API key from the console ApiKey collection, sent as Bearer token.
            Also accepts session cookies for browser-based auth.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Attempt cohort data
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Analytics_getAttemptCohort_Response_200'
        '400':
          description: Invalid input
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BadRequestErrorResponse'
        '401':
          description: Unauthorized access
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnauthorizedErrorResponse'
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalServerErrorResponse'
servers:
  - url: https://api.smallest.ai/atoms/v1
    description: Production server
components:
  schemas:
    AnalyticsAttemptCohortGetResponsesContentApplicationJsonSchemaDataCohortsItems:
      type: object
      properties:
        attemptNumber:
          type: number
          format: double
        totalCalls:
          type: number
          format: double
        answeredCalls:
          type: number
          format: double
        pickupRate:
          type: number
          format: double
        cumulativeAnswered:
          type: number
          format: double
        cumulativeRate:
          type: number
          format: double
        marginalGain:
          type: number
          format: double
      title: >-
        AnalyticsAttemptCohortGetResponsesContentApplicationJsonSchemaDataCohortsItems
    AnalyticsDateRange:
      type: object
      properties:
        from:
          type: string
          format: date
        to:
          type: string
          format: date
      title: AnalyticsDateRange
    AnalyticsAttemptCohortGetResponsesContentApplicationJsonSchemaData:
      type: object
      properties:
        orgId:
          type: string
        cohorts:
          type: array
          items:
            $ref: >-
              #/components/schemas/AnalyticsAttemptCohortGetResponsesContentApplicationJsonSchemaDataCohortsItems
        totalUniqueNumbers:
          type: number
          format: double
        maxAttemptsSeen:
          type: number
          format: double
        avgAttemptsToPickup:
          type: number
          format: double
        period:
          $ref: '#/components/schemas/AnalyticsDateRange'
      title: AnalyticsAttemptCohortGetResponsesContentApplicationJsonSchemaData
    Analytics_getAttemptCohort_Response_200:
      type: object
      properties:
        success:
          type: boolean
        data:
          $ref: >-
            #/components/schemas/AnalyticsAttemptCohortGetResponsesContentApplicationJsonSchemaData
      title: Analytics_getAttemptCohort_Response_200
    BadRequestErrorResponse:
      type: object
      properties:
        status:
          type: boolean
        errors:
          type: array
          items:
            type: string
      title: BadRequestErrorResponse
    UnauthorizedErrorResponse:
      type: object
      properties:
        status:
          type: boolean
        errors:
          type: array
          items:
            type: string
      title: UnauthorizedErrorResponse
    InternalServerErrorResponse:
      type: object
      properties:
        status:
          type: boolean
        errors:
          type: array
          items:
            type: string
      title: InternalServerErrorResponse
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >-
        API key from the console ApiKey collection, sent as Bearer token. Also
        accepts session cookies for browser-based auth.

```

## Examples



**Request**

```json
{}
```

**Response**

```json
{
  "success": true,
  "data": {
    "orgId": "org_9f8b7c6d5e4a3b2c1d0e",
    "cohorts": [
      {
        "attemptNumber": 1,
        "totalCalls": 1500,
        "answeredCalls": 900,
        "pickupRate": 0.6,
        "cumulativeAnswered": 900,
        "cumulativeRate": 0.6,
        "marginalGain": 0.6
      },
      {
        "attemptNumber": 2,
        "totalCalls": 800,
        "answeredCalls": 320,
        "pickupRate": 0.4,
        "cumulativeAnswered": 1220,
        "cumulativeRate": 0.61,
        "marginalGain": 0.21
      },
      {
        "attemptNumber": 3,
        "totalCalls": 400,
        "answeredCalls": 120,
        "pickupRate": 0.3,
        "cumulativeAnswered": 1340,
        "cumulativeRate": 0.67,
        "marginalGain": 0.06
      }
    ],
    "totalUniqueNumbers": 1400,
    "maxAttemptsSeen": 3,
    "avgAttemptsToPickup": 1.8,
    "period": {
      "from": "2023-01-01",
      "to": "2023-01-31"
    }
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.smallest.ai/atoms/v1/analytics/attempt-cohort"

payload = {}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://api.smallest.ai/atoms/v1/analytics/attempt-cohort';
const options = {
  method: 'GET',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

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"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.smallest.ai/atoms/v1/analytics/attempt-cohort"

	payload := strings.NewReader("{}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	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/analytics/attempt-cohort")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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/analytics/attempt-cohort")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.smallest.ai/atoms/v1/analytics/attempt-cohort', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.smallest.ai/atoms/v1/analytics/attempt-cohort");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.smallest.ai/atoms/v1/analytics/attempt-cohort")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```