> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Batch-Aufruf abbrechen.

POST https://api.elevenlabs.io/v1/convai/batch-calling/{batch_id}/cancel

Einen laufenden Batch-Anruf abbrechen und den Status aller Empfänger auf abgebrochen setzen.

Reference: https://elevenlabs.io/docs/api-reference/batch-calling/cancel

## Servers

- `https://api.elevenlabs.io` (Production, default)
- `https://api.us.elevenlabs.io` (Production US)
- `https://api.eu.residency.elevenlabs.io` (Production EU)
- `https://api.in.residency.elevenlabs.io` (Production India)
- `https://api.sg.residency.elevenlabs.io` (Production Singapore)

## Request

### Path parameters

- `batch_id` (string, required)

## Response

### 200

Erfolgreiche Antwort

- `id` (string, required)
- `phone_number_id` (string, required, nullable)
- `phone_provider` (enum, required, nullable)
  - Allowed values: `twilio`, `sip_trunk`, `exotel`
- `whatsapp_params` (BatchCallWhatsAppParams, required, nullable)
- `name` (string, required)
- `agent_id` (string, required)
- `branch_id` (string, required, nullable)
- `environment` (string, required, nullable)
- `created_at_unix` (integer, required)
- `scheduled_time_unix` (integer, required)
- `timezone` (string, required, nullable)
- `total_calls_dispatched` (integer, required, default: 0)
- `total_calls_scheduled` (integer, required, default: 0)
- `total_calls_finished` (integer, required, default: 0)
- `last_updated_at_unix` (integer, required)
- `status` (enum, required)
  - Allowed values: `pending`, `in_progress`, `completed`, `failed`, `cancelled`
- `retry_count` (integer, required, default: 0)
- `telephony_call_config` (TelephonyCallConfig-Output, required)
- `target_concurrency_limit` (integer, required, nullable) — Maximale Anzahl gleichzeitiger Anrufe für diesen Batch. Wenn festgelegt, wird die Verteilung durch dieses Limit statt durch Kapazitätsprozentsätze von Workspace oder Agent gesteuert.
- `agent_name` (string, required)
- `branch_name` (string, required, nullable)

## Errors

### 422 Unprocessable Entity Error

Validierungsfehler

- `detail` (list of ValidationError, optional)

## Types

### BatchCallWhatsAppParams

- `whatsapp_call_permission_request_template_name` (string, required)
- `whatsapp_call_permission_request_template_language_code` (string, required)
- `whatsapp_phone_number_id` (string, optional, nullable)

### TelephonyCallConfig-Output

- `ringing_timeout_secs` (integer, optional, default: 60) — Wie lange der Empfänger vor dem Abbruch in Sekunden klingeln soll. Beachten Sie, dass dies auch durch die Einschränkungen des Anbieters begrenzt wird.
- `twilio_call_recording_enabled` (boolean, optional, default: false) — Ob der Anruf mit der Anrufaufzeichnung von Twilio aufgezeichnet werden soll. Wird für Anbieter außer Twilio ignoriert. Aufzeichnungen werden in Ihrem Twilio-Konto gespeichert.
- `twilio_machine_detection` (TwilioMachineDetectionConfig, optional, nullable) — Konfiguration für Twilios netzbetreiberseitige Anrufbeantwortererkennung (AMD). Weglassen oder auf null setzen, um sie zu deaktivieren. Wird für andere Anbieter als Twilio und für eingehende Anrufe ignoriert. Das Ergebnis wird als eigenes Webhook-Ereignis `answering_machine_detection` übermittelt. Dafür muss dieses Ereignis in den Webhook-Einstellungen des Workspace oder Agents aktiviert sein; es ist nicht Teil der Unterhaltung oder des Post-Call-Webhooks. Die Erkennung läuft asynchron und verzögert daher nie den Beginn der Unterhaltung. Das Ergebnis kann zu jedem Zeitpunkt während des Anrufs eintreffen -- mit `detect_message_end` sogar nach dessen Ende. Twilio berechnet AMD separat.

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)

### TwilioMachineDetectionConfig

Wie Twilios netzbetreiberseitige Anrufbeantwortererkennung (AMD) bei einem Anruf ausgeführt wird.

- `mode` (enum, optional, default: enable) — Wie gründlich die Erkennung sein soll. `enable` gibt ein Ergebnis zurück, sobald Twilio einen Menschen von einer Maschine unterscheiden kann. `detect_message_end` wartet außerdem, bis die Mailboxansage beendet ist, wodurch die Ergebnisse `machine_end_*` erzeugt werden, liefert aber später ein Ergebnis.
  - Allowed values: `enable`, `detect_message_end`

### ValidationErrorLocItems

## Examples

**Response**

```json
{
  "id": "string",
  "phone_number_id": "string",
  "phone_provider": "twilio",
  "whatsapp_params": {
    "whatsapp_call_permission_request_template_name": "string",
    "whatsapp_call_permission_request_template_language_code": "string",
    "whatsapp_phone_number_id": "string"
  },
  "name": "string",
  "agent_id": "string",
  "branch_id": "string",
  "environment": "string",
  "created_at_unix": 1,
  "scheduled_time_unix": 1,
  "timezone": "string",
  "total_calls_dispatched": 0,
  "total_calls_scheduled": 0,
  "total_calls_finished": 0,
  "last_updated_at_unix": 1,
  "status": "pending",
  "retry_count": 0,
  "telephony_call_config": {
    "ringing_timeout_secs": 60,
    "twilio_call_recording_enabled": false,
    "twilio_machine_detection": {
      "mode": "enable"
    }
  },
  "target_concurrency_limit": 1,
  "agent_name": "string",
  "branch_name": "string"
}
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/convai/batch-calling/batch_id/cancel"

response = requests.post(url)

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/convai/batch-calling/batch_id/cancel';
const options = {method: 'POST'};

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.elevenlabs.io/v1/convai/batch-calling/batch_id/cancel"

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

	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.elevenlabs.io/v1/convai/batch-calling/batch_id/cancel")

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

request = Net::HTTP::Post.new(url)

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.post("https://api.elevenlabs.io/v1/convai/batch-calling/batch_id/cancel")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.elevenlabs.io/v1/convai/batch-calling/batch_id/cancel');

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

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/convai/batch-calling/batch_id/cancel");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/convai/batch-calling/batch_id/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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