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

# Outbound-Kampagne stoppen

POST https://api.elevenlabs.io/v1/convai/outbound-campaigns/campaigns/{campaign_id}/stop

Stoppt eine Outbound-Kampagne endgültig: Geplante Anrufe werden abgebrochen und kein Lead wird erneut angerufen. Gibt `202` mit der Kampagne `stopping` zurück, während bereits gestartete Anrufe noch beendet werden.

Reference: https://elevenlabs.io/docs/eleven-agents/api-reference/campaigns/stop

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

- `campaign_id` (string, required)

## Response

### 200

Erfolgreiche Antwort

- `campaign_id` (string, required)
- `call_name` (string, required) — Der Name der Kampagne.
- `agent_id` (string, required)
- `channel_config` (CampaignResponseChannelConfig, required)
- `status` (enum, required) — `attention` bedeutet, dass ein offener Prüfpunkt einige Anrufe der Kampagne zurückhält, während die übrigen fortgesetzt werden. `stopping` bedeutet, dass geplante Anrufe abgebrochen werden und bereits gestartete Anrufe beendet werden.
  - Allowed values: `active`, `paused`, `stopping`, `stopped`, `completed`, `failed`, `attention`
- `policy` (CampaignPolicySnapshot, required) — Die Richtlinie, die die Kampagne bei ihrer Erstellung verwendet hat.
- `variant` (enum, required)
  - Allowed values: `simple`, `advanced`
- `created_at_unix` (integer, required)
- `updated_at_unix` (integer, required)
- `channel` (enum, required)
  - Allowed values: `phone`, `whatsapp`
- `mode` (enum, required)
  - Allowed values: `voice`, `message`
- `counts` (CampaignSummaryCounts, required)
- `agent_name` (string, required, default: )
- `source` (enum, optional) — Ob die Kampagne in der App oder über die API erstellt wurde.
  - Allowed values: `ui`, `api`
- `outcome` (CampaignResponseOutcome, optional) — Das Ergebnis, das für die Anrufe der Kampagne als Erfolg zählt.
- `scheduled_time_unix` (integer, optional) — Zeitpunkt, zu dem die Kampagne mit Anrufen beginnt; nicht gesetzt, um nach der Erstellung zu starten.
- `branch_id` (string, optional) — Der Agent-Zweig, mit dem die Kampagne anruft.
- `environment` (string, optional) — Die Umgebung, in der die Umgebungsvariablen des Agenten aufgelöst werden.
- `target_concurrency_limit` (integer, optional) — Die maximale Anzahl von Anrufen, die die Kampagne gleichzeitig tätigt.

## Errors

### 422 Outbound Campaigns Stop Request Unprocessable Entity Error

Validierungsfehler

- `detail` (list of ValidationError, optional)

## Types

### CampaignResponseChannelConfig

- `channel`: `phone`
  - `agent_phone_number_id` (string, required) — Die Telefonnummer, von der aus angerufen wird.
  - `mode_config` (PhoneVoiceConfigOutput, optional)
- `channel`: `whatsapp`
  - `mode_config` (WhatsAppChannelConfigModeConfig, required)
  - `whatsapp_phone_number_id` (string, required) — Die WhatsApp-Telefonnummer, über die Anrufe oder Nachrichten erfolgen.

### CampaignPolicySnapshot

Die Richtlinie, die die Kampagne bei ihrer Erstellung verwendet hat, dargestellt wie eine übermittelte `policy`.

- `timezone` (string, required)
- `retry` (RetryPolicy, required)
- `calling_periods` (list of CallingPeriodPolicy, required)
- `data_collection` (DataCollectionPolicy, required)
- `followup_context` (FollowupContextPolicy, required) — Welche dynamischen Variablen `campaign__` Folgeanrufe erhalten.

### CampaignSummaryCounts

- `leads` (integer, required)
- `terminal_leads` (integer, required) — Leads, die nicht erneut angerufen werden.
- `open_attention` (integer, required) — Noch nicht gelöste Prüfpunkte.
- `delivery` (RecipientDeliveryCounts, optional) — Wie viele Nachrichten jede Stufe erreicht haben; wird beim Abrufen einer einzelnen Nachrichtenkampagne gesetzt.

### CampaignResponseOutcome

- `type`: `data_collection`
  - `data_collection_id` (string, required) — Das Datenerfassungselement des Agenten, das ein erfolgreicher Anruf setzt.
  - `equals` (list of DataCollectionOutcomeEqualsItem, required) — Werte, die als Erfolg zählen und alle dem Typ des Elements entsprechen.
- `type`: `evaluation_criteria`
  - `criteria_id` (string, required) — Das Bewertungskriterium des Agenten, das ein erfolgreicher Anruf erfüllt.

### ValidationError

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

### PhoneVoiceConfigOutput

- `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) — 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.
- `mode` ("voice", optional)

### WhatsAppChannelConfigModeConfig

- `mode`: `message`
  - `template` (WhatsAppTemplate, required) — Die Meta-Vorlage in der bei der Übermittlung genehmigten Form.
- `mode`: `voice`
  - `whatsapp_call_permission_request_template_language_code` (string, required) — Der Sprachcode dieser Vorlage.
  - `whatsapp_call_permission_request_template_name` (string, required) — Die genehmigte Vorlage, die die Kontaktperson um Erlaubnis zum Anrufen bittet.

### RetryPolicy

- `retry_delay_seconds` (integer, optional, default: 600) — Wie lange vor einem kurzen Wiederholungsversuch gewartet wird.
- `max_short_retries` (integer, optional, default: 1) — Wiederholungsversuche, die ein Anruffenster nach einem fehlgeschlagenen Anruf erlaubt. Sobald sie aufgebraucht sind, wartet der nächste Wiederholungsversuch auf das folgende Fenster, das erneut beginnt.
- `max_total_calls` (integer, optional, default: 6) — Die maximale Anzahl von Anrufen für einen Lead, einschließlich des ersten.
- `max_callbacks` (integer, optional, default: 2) — Die maximale Anzahl von Rückrufen, die für eine Nummer berücksichtigt wird.
- `max_redirects` (integer, optional, default: 2) — Die maximale Anzahl, wie oft ein Lead einer Anfrage folgt, eine andere Nummer anzurufen.
- `interval_placement` (enum, optional, default: start) — An welcher Stelle in einem späteren Anruffenster ein verschobener Anruf erfolgt: bei `start`, zu einem `random` Zeitpunkt oder um `rotate_step_seconds` nach der Stelle versetzt, an der der letzte Anruf in diesem Fenster fehlgeschlagen ist (`rotate`).
  - Allowed values: `start`, `random`, `rotate`
- `rotate_step_seconds` (integer, optional, default: 900) — Um wie viele Positionen die Platzierung `rotate` jeden Anruf verschiebt. Wird nur von `rotate` verwendet.
- `max_consecutive_failures_per_number` (integer, optional) — Anrufe an eine Nummer, die nacheinander fehlschlagen dürfen, bevor der Lead zur nächsten angegebenen Nummer wechselt oder endet, falls keine weitere vorhanden ist. Ein angenommener Anruf oder eine Weiterleitung an eine neue Nummer setzt die Zählung zurück. Wenn nicht gesetzt, gilt nur `max_total_calls`.

### CallingPeriodPolicy

- `weekdays` (list of integer, required)
- `intervals` (list of CallingIntervalPolicy, required) — Zeitfenster an jedem dieser Tage. Sie dürfen sich an keinem Tag überschneiden.

### DataCollectionPolicy

- `callback_time` (string, optional)
- `redirect_phone_number` (string, optional)
- `stop` (string, optional)
- `mappings` (map from string to string, optional) — Kopiert Ergebnisse der Datenerfassung in dynamische Variablen für spätere Anrufe: Jeder Schlüssel ist eine Datenerfassungselement-ID, sein Wert der Name der Variablen.

### FollowupContextPolicy

Welche dynamischen Variablen `campaign__` Folgeanrufe erhalten.

- `call_type` (boolean, optional, default: true) — Übergeben Sie den Anruftyp als `campaign__call_type`.
- `previous_conversation_id` (boolean, optional, default: true) — Übergeben Sie die ID des letzten Gesprächs als `campaign__previous_conversation_id`.
- `previous_summary` (boolean, optional, default: true) — Übergeben Sie die Zusammenfassung des letzten Gesprächs als `campaign__previous_summary`.
- `previous_transcript` (boolean, optional, default: true) — Übergeben Sie das Transkript des letzten Gesprächs als `campaign__previous_transcript`.

### RecipientDeliveryCounts

- `sent` (integer, optional, default: 0)
- `delivered` (integer, optional, default: 0)
- `read` (integer, optional, default: 0)
- `replied` (integer, optional, default: 0)
- `failed` (integer, optional, default: 0)

### DataCollectionOutcomeEqualsItem

- string
- integer
- double
- boolean

### ValidationErrorLocItem

- string
- integer

### 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`
- `actions` (list of TwilioMachineDetectionRule, optional) — Aktionen, die je AMD-Bewertung während des Anrufs ausgeführt werden. Jede Aktion kann in höchstens einer Regel erscheinen. Führen Sie daher alle zugehörigen Bewertungen gemeinsam auf. Bewertungen ohne Regel lassen den Anruf weiterlaufen.

### WhatsAppTemplate

- `name` (string, required)
- `language` (string, required) — https://developers.facebook.com/documentation/business-messaging/whatsapp/templates/supported-languages
- `components` (list of WhatsAppTemplateComponent, required)
- `parameter_format` (enum, optional, default: POSITIONAL)
  - Allowed values: `POSITIONAL`, `NAMED`
- `category` (string, optional) — https://developers.facebook.com/docs/graph-api/reference/whats-app-business-account/message_templates/

### CallingIntervalPolicy

- `start` (string, required) — Lokale Startzeit im Format `HH:MM`.
- `end` (string, required) — Lokale Endzeit im Format `HH:MM`; `24:00` endet um Mitternacht.

### TwilioMachineDetectionRule

Aktion, die bei einem aktiven Anruf für die angegebenen AMD-Bewertungen ausgeführt wird.

- `action` ("hang_up", required)
- `answered_by` (list of enum, required) — Bewertungen, die die Aktion auslösen.
  - Allowed values: `human`, `fax`, `unknown`, `machine_start`, `machine_end_beep`, `machine_end_silence`, `machine_end_other`

### WhatsAppTemplateComponent

- `type` (string, required)
- `format` (string, optional)
- `text` (string, optional)
- `buttons` (list of WhatsAppTemplateComponentButton, optional)

### WhatsAppTemplateComponentButton

- `type` (string, required)
- `text` (string, optional)
- `url` (string, optional)

## Examples

**Response**

```json
{
  "campaign_id": "campaign_id",
  "call_name": "call_name",
  "agent_id": "agent_id",
  "channel_config": {
    "channel": "phone",
    "agent_phone_number_id": "agent_phone_number_id",
    "mode_config": {
      "ringing_timeout_secs": 1,
      "twilio_call_recording_enabled": true,
      "mode": "voice"
    }
  },
  "status": "active",
  "policy": {
    "timezone": "timezone",
    "retry": {
      "retry_delay_seconds": 1,
      "max_short_retries": 1,
      "max_total_calls": 1,
      "max_callbacks": 1,
      "max_redirects": 1,
      "interval_placement": "start",
      "rotate_step_seconds": 1,
      "max_consecutive_failures_per_number": 1
    },
    "calling_periods": [
      {
        "weekdays": [
          1
        ],
        "intervals": [
          {
            "start": "start",
            "end": "end"
          }
        ]
      }
    ],
    "data_collection": {
      "callback_time": "callback_time",
      "redirect_phone_number": "redirect_phone_number",
      "stop": "stop",
      "mappings": {
        "key": "value"
      }
    },
    "followup_context": {
      "call_type": true,
      "previous_conversation_id": true,
      "previous_summary": true,
      "previous_transcript": true
    }
  },
  "variant": "simple",
  "created_at_unix": 1,
  "updated_at_unix": 1,
  "channel": "phone",
  "mode": "voice",
  "counts": {
    "leads": 1,
    "terminal_leads": 1,
    "open_attention": 1,
    "delivery": {
      "sent": 1,
      "delivered": 1,
      "read": 1,
      "replied": 1,
      "failed": 1
    }
  },
  "agent_name": "agent_name",
  "source": "ui",
  "outcome": {
    "type": "data_collection",
    "data_collection_id": "data_collection_id",
    "equals": [
      "equals"
    ]
  },
  "scheduled_time_unix": 1,
  "branch_id": "branch_id",
  "environment": "environment",
  "target_concurrency_limit": 1
}
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/convai/outbound-campaigns/campaigns/campaign_id/stop"

response = requests.post(url)

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/convai/outbound-campaigns/campaigns/campaign_id/stop';
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/outbound-campaigns/campaigns/campaign_id/stop"

	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/outbound-campaigns/campaigns/campaign_id/stop")

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/outbound-campaigns/campaigns/campaign_id/stop")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.elevenlabs.io/v1/convai/outbound-campaigns/campaigns/campaign_id/stop');

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

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/convai/outbound-campaigns/campaigns/campaign_id/stop");
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/outbound-campaigns/campaigns/campaign_id/stop")! 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()
```