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

# Actualizar webhook del espacio de trabajo

PATCH https://api.elevenlabs.io/v1/workspace/webhooks/{webhook_id}
Content-Type: application/json

Actualiza el webhook especificado del espacio de trabajo

Reference: https://elevenlabs.io/docs/api-reference/webhooks/update

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

- `webhook_id` (string, required) — El ID único del webhook

### Body (application/json)

This endpoint expects a Body_Update_workspace_webhook_v1_workspace_webhooks__webhook_id__patch.

- `is_disabled` (boolean, required) — Indica si se debe desactivar o activar el webhook
- `name` (string, required) — El nombre visible del webhook (utilizado únicamente con fines de visualización).
- `retry_enabled` (boolean, optional, nullable) — Indica si se deben activar los reintentos automáticos para fallos transitorios (5xx, 429, tiempo de espera)
- `request_headers` (map from string to string, optional, nullable) — Una lista de cabeceras de solicitud que se incluirán en la entrega del webhook (opcional)
- `events` (list of enum, optional, nullable) — El conjunto completo de eventos del espacio de trabajo a los que debe suscribirse este webhook. El webhook se añade a los eventos de la lista y se elimina de los que no estén en ella. Omítelo para mantener sin cambios las suscripciones a eventos actuales.
  - Allowed values: `voice_library_removal_notice`, `speech_to_text`, `agent_qa`, `flows`

## Response

### 200

Respuesta correcta.

- `status` (string, required) — El estado de la solicitud de actualización parcial del webhook del espacio de trabajo. Si la solicitud se realiza correctamente, el estado será 'ok'. De lo contrario, se devolverá un mensaje de error con estado 500.

## Errors

### 422 Unprocessable Entity Error

Error de validación

- `detail` (list of ValidationError, optional)

## Types

### ValidationError

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

### ValidationErrorLocItems

## Examples

**Request**

```json
{
  "is_disabled": true,
  "name": "My Callback Webhook"
}
```

**Response**

```json
{
  "status": "ok"
}
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/workspace/webhooks/G007vmtq9uWYl7SUW9zGS8GZZa1K"

payload = {
    "is_disabled": True,
    "name": "My Callback Webhook"
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/workspace/webhooks/G007vmtq9uWYl7SUW9zGS8GZZa1K';
const options = {
  method: 'PATCH',
  headers: {'Content-Type': 'application/json'},
  body: '{"is_disabled":true,"name":"My Callback Webhook"}'
};

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.elevenlabs.io/v1/workspace/webhooks/G007vmtq9uWYl7SUW9zGS8GZZa1K"

	payload := strings.NewReader("{\n  \"is_disabled\": true,\n  \"name\": \"My Callback Webhook\"\n}")

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

	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.elevenlabs.io/v1/workspace/webhooks/G007vmtq9uWYl7SUW9zGS8GZZa1K")

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

request = Net::HTTP::Patch.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"is_disabled\": true,\n  \"name\": \"My Callback Webhook\"\n}"

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.patch("https://api.elevenlabs.io/v1/workspace/webhooks/G007vmtq9uWYl7SUW9zGS8GZZa1K")
  .header("Content-Type", "application/json")
  .body("{\n  \"is_disabled\": true,\n  \"name\": \"My Callback Webhook\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.elevenlabs.io/v1/workspace/webhooks/G007vmtq9uWYl7SUW9zGS8GZZa1K', [
  'body' => '{
  "is_disabled": true,
  "name": "My Callback Webhook"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/workspace/webhooks/G007vmtq9uWYl7SUW9zGS8GZZa1K");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"is_disabled\": true,\n  \"name\": \"My Callback Webhook\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "is_disabled": true,
  "name": "My Callback Webhook"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/workspace/webhooks/G007vmtq9uWYl7SUW9zGS8GZZa1K")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()
```