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

# Een uitgaande campagne stoppen

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

Stop een uitgaande campagne definitief: oproepen in de wachtrij worden geannuleerd en geen enkele lead wordt opnieuw gebeld. Retourneert `202` met de campagne op `stopping` zolang reeds geplaatste oproepen nog worden afgerond.

Reference: https://elevenlabs.io/docs/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

Geslaagde response

- `campaign_id` (string, required)
- `call_name` (string, required) — De naam van de campagne.
- `agent_id` (string, required)
- `channel_config` (CampaignResponseChannelConfig, required)
- `status` (enum, required) — `attention` betekent dat een open aandachtspunt sommige oproepen van de campagne tegenhoudt, terwijl de overige doorgaan. `stopping` betekent dat oproepen in de wachtrij worden geannuleerd en al geplaatste oproepen worden afgerond.
  - Allowed values: `active`, `paused`, `stopping`, `stopped`, `completed`, `failed`, `attention`
- `policy` (CampaignPolicySnapshot, required) — Het beleid dat de campagne gebruikte toen deze werd gemaakt.
- `variant` (enum, required)
  - Allowed values: `simple`, `advanced`
- `source` (enum, required, nullable) — Of de campagne in de app of via de API is gemaakt.
  - Allowed values: `ui`, `api`
- `outcome` (CampaignResponseOutcome, required, nullable) — Het resultaat dat als succes geldt voor de oproepen van de campagne.
- `created_at_unix` (integer, required)
- `scheduled_time_unix` (integer, required, nullable) — Wanneer de campagne begint met bellen; niet ingesteld om te starten zodra deze is gemaakt.
- `updated_at_unix` (integer, required)
- `branch_id` (string, required, nullable) — De agentbranch waarmee de campagne belt.
- `environment` (string, required, nullable) — De omgeving waarin de omgevingsvariabelen van de agent worden opgelost.
- `target_concurrency_limit` (integer, required, nullable) — Het maximale aantal oproepen dat de campagne tegelijk plaatst.
- `channel` (enum, required)
  - Allowed values: `phone`, `whatsapp`
- `mode` (enum, required)
  - Allowed values: `voice`, `message`
- `counts` (CampaignSummaryCounts, required)
- `agent_name` (string, required, default: )

## Errors

### 422 Unprocessable Entity Error

Validatiefout

- `detail` (list of ValidationError, optional)

## Types

### CampaignResponseChannelConfig

- `channel`: `phone` (PhoneChannelConfig)
  - `agent_phone_number_id` (string, required) — Het telefoonnummer waarmee wordt gebeld.
  - `mode_config` (PhoneVoiceConfig-Output, optional)
- `channel`: `whatsapp` (WhatsAppChannelConfig)
  - `mode_config` (WhatsAppChannelConfigModeConfig, required)
  - `whatsapp_phone_number_id` (string, required) — Het WhatsApp-telefoonnummer waarmee je belt of berichten verstuurt.

### CampaignPolicySnapshot

Het beleid dat de campagne gebruikte toen deze werd gemaakt, weergegeven zoals een ingediend `policy`.

- `timezone` (string, required)
- `retry` (RetryPolicy, required)
- `calling_periods` (list of CallingPeriodPolicy, required)
- `data_collection` (DataCollectionPolicy, required)
- `followup_context` (FollowupContextPolicy, required) — Welke dynamische variabelen van `campaign__` vervolgoproepen krijgen.

### CampaignResponseOutcome

Het resultaat dat als succes geldt voor de oproepen van de campagne.

- `type`: `data_collection` (DataCollectionOutcome)
  - `data_collection_id` (string, required) — Het gegevensverzamelingsitem van de agent dat een succesvolle oproep instelt.
  - `equals` (list of CampaignResponseOutcomeDiscriminatorMappingDataCollectionEqualsItems, required) — Waarden die als succes gelden, allemaal van het type van het item.
- `type`: `evaluation_criteria` (EvaluationCriterionOutcome)
  - `criteria_id` (string, required) — Het evaluatiecriterium van de agent waaraan een succesvolle oproep voldoet.

### CampaignSummaryCounts

- `leads` (integer, required)
- `terminal_leads` (integer, required) — Leads die niet opnieuw worden gebeld.
- `open_attention` (integer, required) — Aandachtspunten die nog niet zijn opgelost.
- `delivery` (RecipientDeliveryCounts, optional, nullable) — Hoeveel berichten elke fase hebben bereikt; ingesteld bij het ophalen van één berichtencampagne.

### ValidationError

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

### PhoneVoiceConfig-Output

- `ringing_timeout_secs` (integer, optional, default: 60) — Hoe lang de ontvanger moet worden gebeld voordat wordt gestopt, in seconden. Dit wordt ook beperkt door de eigen beperkingen van de provider.
- `twilio_call_recording_enabled` (boolean, optional, default: false) — Of het gesprek moet worden opgenomen met Twilio-gespreksopname. Wordt genegeerd voor niet-Twilio-providers. Opnames worden opgeslagen in je Twilio-account.
- `twilio_machine_detection` (TwilioMachineDetectionConfig, optional, nullable) — Configuratie voor detectie van voicemail op providerniveau van Twilio (AMD). Laat weg of stel in op null om deze uit te schakelen. Wordt genegeerd voor niet-Twilio-providers en voor inkomende gesprekken. Het resulterende oordeel wordt geleverd als een eigen `answering_machine_detection`-webhookgebeurtenis. Hiervoor moet die gebeurtenis zijn ingeschakeld in de webhookinstellingen van de workspace of agent; deze maakt geen deel uit van het gesprek of de webhook na het gesprek. Detectie wordt asynchroon uitgevoerd, zodat deze de start van het gesprek nooit vertraagt. Het oordeel kan op elk moment tijdens het gesprek binnenkomen -- met `detect_message_end` zelfs nadat het gesprek is beëindigd. Twilio factureert AMD afzonderlijk.
- `mode` ("voice", optional, default: voice)

### WhatsAppChannelConfigModeConfig

- `mode`: `message` (WhatsAppMessageConfig)
  - `template` (WhatsAppTemplate, required) — De Meta-template zoals deze bij indiening is goedgekeurd.
- `mode`: `voice` (WhatsAppVoiceConfig)
  - `whatsapp_call_permission_request_template_language_code` (string, required) — De taalcode van die template.
  - `whatsapp_call_permission_request_template_name` (string, required) — De goedgekeurde template die de contactpersoon om toestemming vraagt om te bellen.

### RetryPolicy

- `retry_delay_seconds` (integer, optional, default: 600) — Hoe lang er moet worden gewacht vóór een korte nieuwe poging.
- `max_short_retries` (integer, optional, default: 1) — Nieuwe pogingen die een belvenster toestaat na een mislukte oproep. Zodra deze zijn verbruikt, wacht de volgende nieuwe poging op het volgende venster, dat opnieuw begint.
- `max_total_calls` (integer, optional, default: 6) — Het maximale aantal oproepen dat een lead ontvangt, inclusief de eerste.
- `max_callbacks` (integer, optional, default: 2) — Het maximale aantal terugbelverzoeken dat voor één nummer wordt uitgevoerd.
- `max_redirects` (integer, optional, default: 2) — Het maximale aantal keren dat een lead een verzoek volgt om een ander nummer te bellen.
- `interval_placement` (enum, optional, default: start) — Waar een uitgestelde oproep in een later belvenster terechtkomt: bij de `start`, op een `random` tijdstip, of `rotate`d `rotate_step_seconds` na het punt waarop de laatste oproep in dat venster mislukte.
  - Allowed values: `start`, `random`, `rotate`
- `rotate_step_seconds` (integer, optional, default: 900) — Hoeveel posities `rotate` elke oproep verplaatst. Alleen gebruikt door `rotate`.
- `max_consecutive_failures_per_number` (integer, optional, nullable) — Oproepen naar één nummer die achter elkaar mogen mislukken voordat de lead doorgaat naar het volgende opgegeven nummer, of stopt als er geen volgend nummer is. Een beantwoorde oproep of een doorschakeling naar een nieuw nummer start de teller opnieuw. Als dit niet is ingesteld, geldt alleen `max_total_calls`.

### CallingPeriodPolicy

- `weekdays` (list of integer, required)
- `intervals` (list of CallingIntervalPolicy, required) — Vensters op elk van die dagen. Ze mogen op geen enkele dag overlappen.

### DataCollectionPolicy

- `callback_time` (string, optional, nullable)
- `redirect_phone_number` (string, optional, nullable)
- `stop` (string, optional, nullable)
- `mappings` (map from string to string, optional) — Kopieert resultaten van gegevensverzameling naar dynamische variabelen voor latere oproepen: elke sleutel is een ID van een gegevensverzamelingsitem en de waarde is de naam van de variabele.

### FollowupContextPolicy

Welke dynamische variabelen van `campaign__` vervolgoproepen krijgen.

- `call_type` (boolean, optional, default: true) — Geef het oproeptype door als `campaign__call_type`.
- `previous_conversation_id` (boolean, optional, default: true) — Geef de ID van het laatste gesprek door als `campaign__previous_conversation_id`.
- `previous_summary` (boolean, optional, default: true) — Geef de samenvatting van het laatste gesprek door als `campaign__previous_summary`.
- `previous_transcript` (boolean, optional, default: true) — Geef het transcript van het laatste gesprek door als `campaign__previous_transcript`.

### CampaignResponseOutcomeDiscriminatorMappingDataCollectionEqualsItems

- string
- integer
- double
- boolean

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

### ValidationErrorLocItems

- string
- integer

### TwilioMachineDetectionConfig

Hoe Twilio's detectie van antwoordapparaten op providerniveau (AMD) moet worden uitgevoerd voor een gesprek.

- `mode` (enum, optional, default: enable) — Hoe grondig de detectie moet zijn. `enable` retourneert een beoordeling zodra Twilio een mens van een machine kan onderscheiden. `detect_message_end` wacht ook tot de voicemailbegroeting is afgelopen, wat de `machine_end_*`-beoordelingen oplevert, maar retourneert later een resultaat.
  - Allowed values: `enable`, `detect_message_end`
- `actions` (list of TwilioMachineDetectionRule, optional) — Acties die tijdens het gesprek moeten worden uitgevoerd per AMD-beoordeling. Elke actie kan in maximaal één regel voorkomen, dus vermeld alle bijbehorende beoordelingen samen. Beoordelingen zonder regel laten het gesprek doorgaan.

### 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, nullable) — https://developers.facebook.com/docs/graph-api/reference/whats-app-business-account/message_templates/

### CallingIntervalPolicy

- `start` (string, required) — Lokale starttijd als `HH:MM`.
- `end` (string, required) — Lokale eindtijd als `HH:MM`; `24:00` eindigt om middernacht.

### TwilioMachineDetectionRule

Actie die tijdens een livegesprek moet worden uitgevoerd voor de opgegeven AMD-beoordelingen.

- `action` (enum, required)
  - Allowed values: `hang_up`
- `answered_by` (list of enum, required) — Beoordelingen die de actie activeren.
  - Allowed values: `human`, `fax`, `unknown`, `machine_start`, `machine_end_beep`, `machine_end_silence`, `machine_end_other`

### WhatsAppTemplateComponent

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

### WhatsAppTemplateComponentButton

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

## Examples

**Response**

```json
{
  "campaign_id": "string",
  "call_name": "string",
  "agent_id": "string",
  "channel_config": {
    "channel": "phone",
    "agent_phone_number_id": "string",
    "mode_config": {
      "ringing_timeout_secs": 60,
      "twilio_call_recording_enabled": false,
      "twilio_machine_detection": {
        "mode": "enable",
        "actions": [
          {
            "action": "hang_up",
            "answered_by": [
              "human"
            ]
          }
        ]
      },
      "mode": "voice"
    }
  },
  "status": "active",
  "policy": {
    "timezone": "string",
    "retry": {
      "retry_delay_seconds": 600,
      "max_short_retries": 1,
      "max_total_calls": 6,
      "max_callbacks": 2,
      "max_redirects": 2,
      "interval_placement": "start",
      "rotate_step_seconds": 900,
      "max_consecutive_failures_per_number": 1
    },
    "calling_periods": [
      {
        "weekdays": [
          1
        ],
        "intervals": [
          {
            "start": "string",
            "end": "string"
          }
        ]
      }
    ],
    "data_collection": {
      "callback_time": "string",
      "redirect_phone_number": "string",
      "stop": "string",
      "mappings": {}
    },
    "followup_context": {
      "call_type": true,
      "previous_conversation_id": true,
      "previous_summary": true,
      "previous_transcript": true
    }
  },
  "variant": "simple",
  "source": "ui",
  "outcome": {
    "type": "evaluation_criteria",
    "criteria_id": "string"
  },
  "created_at_unix": 1,
  "scheduled_time_unix": 1,
  "updated_at_unix": 1,
  "branch_id": "string",
  "environment": "string",
  "target_concurrency_limit": 1,
  "channel": "phone",
  "mode": "voice",
  "counts": {
    "leads": 1,
    "terminal_leads": 1,
    "open_attention": 1,
    "delivery": {
      "sent": 0,
      "delivered": 0,
      "read": 0,
      "replied": 0,
      "failed": 0
    }
  },
  "agent_name": ""
}
```

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