From your first API call to production

Deploy Docker → Configure in the Web GUI → Receive events

Download the example (Python source, Compose overlay and instructions)

Basic integration: provide a backend webhook receiver for Watch POST notifications. GET queries are optional. Receiving alerts does not require implementing camera or rule configuration APIs. Jump to POST / GET examples ↓

{
  "id": "evt_example",
  "schema": "sentinel.event.v1",
  "type": "monitor.alert.raised",
  "severity": "critical",
  "state": "raised",
  "created_at": "2026-09-07T12:00:00Z",
  "source_id": "src_camera03",
  "monitor_id": "mon_restricted_area",
  "title": "Person entered restricted area",
  "summary": "Camera 03 detected a person entering the specified area.",
  "evidence": {
    "image_url": "/v1/events/evt_example/image"
  }
}

1. Start Watch and the example receiver

Obtain the current Sentinel source deployment kit from Tensor Dynamics and install Docker Compose v2 and Python 3. Extract the example into the kit root, preserving the deploy/ and docs/ paths. This example uses a reachable RTSP camera and Gemini; inference images go to the cloud model and use your API quota.

cd deploy/api
./bootstrap.sh cloud_gemini

Run bootstrap only for a fresh deployment; keep an existing .env. Edit these values in .env, replacing the camera address and port. Keep the generated API key and webhook signing secret.

SENTINEL_GEMINI_API_KEY=your-gemini-api-key
SENTINEL_RTSP_ALLOWED_HOSTS=10.40.8.21:554
SENTINEL_WEBHOOK_ALLOWED_HOSTS=partner-receiver:9090

docker compose -f docker-compose.yml -f partner-webhook.compose.yml --profile ui up -d --build

This builds the API and console from the kit and starts the receiver on the same Docker network. Use a private model · Deployment options

2. Configure the camera and rule in the Web GUI

1. On the server, open http://localhost:3000. Leave API base URL blank, enter SENTINEL_API_KEY from .env, and select Connect and verify. Use an SSH tunnel or protected reverse proxy for remote access.
2. In Sources, add the RTSP camera, test the connection and check the preview.
3. In Monitors, select the camera, describe the condition—for example, notify when a person enters a restricted area—then enable and test the monitor. Validate the model on representative site images.

3. Receive the first webhook

In Webhooks, add an endpoint with these values:

Name: Partner receiver
Destination URL: http://partner-receiver:9090/events
Signing secret environment variable: SENTINEL_WEBHOOK_SIGNING_SECRET
Enabled: on
Dry run: off
Severity: critical
State: raised

The signing-secret field takes the environment variable name, not the secret value. Leave event types, source IDs and monitor IDs unrestricted for the first test. Save, select Test signed delivery and use critical severity.

docker compose -f docker-compose.yml -f partner-webhook.compose.yml logs --tail=20 partner-receiver

An accepted log with evt_… and whd_… means the receiver verified the signature and committed the event to SQLite. Next, trigger the monitoring condition and confirm a real alert arrives. The test notification verifies delivery, not camera or model acceptance.

# Inside the receiver's do_POST handler (shortened)
raw = self.rfile.read(length)
event = verify(raw, self.headers, secret)
fresh = accept(database, event, self.headers["X-Sentinel-Delivery-ID"], raw)
self.send_response(204)
self.end_headers()

# Set these in the receiver's environment / secret manager:
# SENTINEL_WEBHOOK_SIGNING_SECRET = same secret as Watch
# RECEIVER_HOST = 0.0.0.0
# RECEIVER_PORT = 9090
python3 partner_webhook_receiver.py

# Query a page of stored events
curl --fail-with-body 'http://localhost:8000/v1/events?limit=10' \
  -H "Authorization: Bearer $SENTINEL_API_KEY"

{
  "object": "list",
  "data": [],
  "has_more": false,
  "next_cursor": null
}

# Set NEXT_CURSOR to the returned next_cursor value
curl --fail-with-body --get 'http://localhost:8000/v1/events' \
  -H "Authorization: Bearer $SENTINEL_API_KEY" \
  --data-urlencode "after=$NEXT_CURSOR" \
  --data-urlencode 'limit=10'

# Set EVENT_ID to a real id from data[] or a webhook
curl --fail-with-body "http://localhost:8000/v1/events/$EVENT_ID" \
  -H "Authorization: Bearer $SENTINEL_API_KEY"

# Download evidence when the event has an image
curl --fail "http://localhost:8000/v1/events/$EVENT_ID/image" \
  -H "Authorization: Bearer $SENTINEL_API_KEY" \
  --output event.jpg

Connect your own system

The example verifies, deduplicates and stores events. Connect its inbox to your alarm list or workflow using typed fields such as type, severity and state, rather than parsing model prose. Webhooks carry alerts and errors, not every ordinary inference.

For production, use HTTPS, share the signing secret with Watch, verify the original request body and return 2xx promptly after durable acceptance. Deduplicate retries by delivery ID; different deliveries for one event may be state updates. Add business processing, retention and capacity planning to the SQLite example.

Full webhook contract · Production deployment · Build your own settings UI: full API