> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.aurasos.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.aurasos.com/_mcp/server.

# Register a webhook

POST https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks
Content-Type: application/json

Registers a webhook so AURA posts event payloads to your URL as callouts, subscriptions, and customers change. Provide the events to subscribe to and any custom headers to include on each delivery. The URL must be HTTPS, and each customer source has a single active webhook — registering replaces it. The API path retains `notifiers`; docs use webhook terminology.

Reference: https://docs.aurasos.com/api-reference/webhooks/create-webhook

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Servers

- `https://staging-panic.aura.services` (Staging, default)
- `https://panic.aura.services` (Production)

## Request

### Body (application/json)

This endpoint expects a WebhookCreateRequest.

- `url` (string, required) — HTTPS endpoint AURA posts event payloads to.
- `events` (list of string, required) — Event types to subscribe to, for example `NEW_CALLOUT`, `CALLOUT_CLOSED`.
- `method` (string, optional, default: webhook) — Delivery method. Use `webhook`.
- `headers` (map from string to string, optional) — Custom headers included on every delivery, for example an `authorization` token.

## Response

### 200

Successful.

- `message` (string, optional)
- `notifier` (WebhookNotifier, optional)

## Errors

### 400 Bad Request Error

Bad request.

- `message` (string, optional)
- `errors` (ErrorResponseErrors, optional) — Error detail. May be a string, an array of strings, or an object (some routes return a serialized error object).

### 401 Unauthorized Error

Unauthorized.

- `message` (string, optional)
- `errors` (ErrorResponseErrors, optional) — Error detail. May be a string, an array of strings, or an object (some routes return a serialized error object).

## Types

### WebhookNotifier

- `config` (list of WebhookNotifierConfigItems, optional)

### ErrorResponseErrors

Error detail. May be a string, an array of strings, or an object (some routes return a serialized error object).

- string
- list of string
- map from string to any

### WebhookNotifierConfigItems

- `url` (string, optional)
- `events` (list of string, optional)
- `method` (string, optional)
- `ignorePath` (boolean, optional)
- `headers` (map from string to string, optional)

## Examples

**Request**

```json
{
  "url": "https://your-server.example.com/api/webhooks/events",
  "events": [
    "NEW_CALLOUT",
    "CALLOUT_CLOSED"
  ],
  "method": "webhook",
  "headers": {
    "authorization": "Bearer token"
  }
}
```

**Response**

```json
{
  "message": "string",
  "notifier": {
    "config": [
      {
        "url": "string",
        "events": [
          "string"
        ],
        "method": "string",
        "ignorePath": true,
        "headers": {}
      }
    ]
  }
}
```

**SDK Code**

```python Success
import requests

url = "https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks"

payload = {
    "url": "https://your-server.example.com/api/webhooks/events",
    "events": ["NEW_CALLOUT", "CALLOUT_CLOSED"],
    "method": "webhook",
    "headers": { "authorization": "Bearer token" }
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Success
const url = 'https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"url":"https://your-server.example.com/api/webhooks/events","events":["NEW_CALLOUT","CALLOUT_CLOSED"],"method":"webhook","headers":{"authorization":"Bearer token"}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks"

	payload := strings.NewReader("{\n  \"url\": \"https://your-server.example.com/api/webhooks/events\",\n  \"events\": [\n    \"NEW_CALLOUT\",\n    \"CALLOUT_CLOSED\"\n  ],\n  \"method\": \"webhook\",\n  \"headers\": {\n    \"authorization\": \"Bearer token\"\n  }\n}")

	req, _ := http.NewRequest("POST", 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 Success
require 'uri'
require 'net/http'

url = URI("https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"url\": \"https://your-server.example.com/api/webhooks/events\",\n  \"events\": [\n    \"NEW_CALLOUT\",\n    \"CALLOUT_CLOSED\"\n  ],\n  \"method\": \"webhook\",\n  \"headers\": {\n    \"authorization\": \"Bearer token\"\n  }\n}"

response = http.request(request)
puts response.read_body
```

```java Success
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"url\": \"https://your-server.example.com/api/webhooks/events\",\n  \"events\": [\n    \"NEW_CALLOUT\",\n    \"CALLOUT_CLOSED\"\n  ],\n  \"method\": \"webhook\",\n  \"headers\": {\n    \"authorization\": \"Bearer token\"\n  }\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks', [
  'body' => '{
  "url": "https://your-server.example.com/api/webhooks/events",
  "events": [
    "NEW_CALLOUT",
    "CALLOUT_CLOSED"
  ],
  "method": "webhook",
  "headers": {
    "authorization": "Bearer token"
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Success
using RestSharp;

var client = new RestClient("https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"url\": \"https://your-server.example.com/api/webhooks/events\",\n  \"events\": [\n    \"NEW_CALLOUT\",\n    \"CALLOUT_CLOSED\"\n  ],\n  \"method\": \"webhook\",\n  \"headers\": {\n    \"authorization\": \"Bearer token\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Success
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "url": "https://your-server.example.com/api/webhooks/events",
  "events": ["NEW_CALLOUT", "CALLOUT_CLOSED"],
  "method": "webhook",
  "headers": ["authorization": "Bearer token"]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://staging-panic.aura.services/panic-api/v2/notifiers/webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```