Overview
Webhooks allow you to receive notifications about events on the tikento platform in real time. When an event occurs (new registration, successful payment, event cancellation), tikento sends an HTTP POST request to your URL with the event data.
Webhooks are available on Pro, Business, and Enterprise plans.
Setup
Adding a webhook URL
- Open Settings in the sidebar menu.
- Go to the "Integrations" section.
- Click "Add webhook".
- Enter the endpoint URL (HTTPS required).
- Select the event types you want to receive.
- Click "Save".
After saving, tikento will send a test request to the specified URL to verify availability.
Webhook secret
When creating a webhook, the system generates a webhook secret -- a string for signature verification. Save it in a secure location. The secret is shown only once.
Event types
| Event | Description | Plans |
|---|---|---|
registration.created | New registration created | Pro, Business, Enterprise |
registration.updated | Registration status changed (moderation, cancellation) | Pro, Business, Enterprise |
payment.completed | Payment successfully completed | Pro, Business, Enterprise |
payment.refunded | Payment refunded | Pro, Business, Enterprise |
event.published | Event published | Business, Enterprise |
event.cancelled | Event cancelled | Business, Enterprise |
checkin.scanned | Ticket checked in (QR scan or manual) | Business, Enterprise |
lead.captured | New lead captured via registration form | Enterprise |
You can subscribe to all types available on your plan or select only the ones you need.
Limits
| Pro | Business | Enterprise | |
|---|---|---|---|
| Max webhook endpoints | 3 | 10 | 50 |
| Delivery history retention | 7 days | 30 days | 90 days |
| HTTP timeout per request | 10 seconds | 10 seconds | 10 seconds |
Payload format
Each webhook is sent as an HTTP POST with a JSON body.
Request headers
| Header | Description |
|---|---|
Content-Type | application/json |
X-Tikento-Event | Event type (e.g., registration.created) |
X-Tikento-Signature | Signature: t=<unix_ts>,v1=<hmac_hex> |
X-Tikento-Timestamp | Unix timestamp of sending (seconds) |
X-Tikento-Request-Id | Unique request identifier |
Body structure
{
"event": "registration.created",
"timestamp": "2026-06-30T14:30:00Z",
"requestId": "req_01912345abcdef",
"data": {
"id": "01912345-6789-7abc-def0-123456789abc",
"event_id": "01900000-0000-7000-0000-000000000001",
"status": "registered",
"fields": {
"registrant_email": "user@example.com",
"first_name": "Ivan",
"last_name": "Petrov"
},
"created_at": "2026-06-30T14:30:00Z"
}
}
The requestId field is present in every webhook. Use it for deduplication and when contacting support.
Payload examples by event type
registration.created
{
"event": "registration.created",
"timestamp": "2026-06-30T14:30:00Z",
"requestId": "req_01912345abcdef",
"data": {
"id": "01912345-6789-7abc-def0-123456789abc",
"event_id": "01900000-0000-7000-0000-000000000001",
"event_slug": "tech-conference-2026",
"status": "registered",
"ticket_definition_id": "01900000-0000-7000-0000-000000000010",
"fields": {
"registrant_email": "user@example.com",
"first_name": "Ivan",
"last_name": "Petrov",
"company": "Acme Corp"
},
"created_at": "2026-06-30T14:30:00Z"
}
}
payment.completed
{
"event": "payment.completed",
"timestamp": "2026-06-30T14:31:00Z",
"requestId": "req_01912345abcdf0",
"data": {
"id": "01912345-6789-7abc-def0-000000000099",
"registration_id": "01912345-6789-7abc-def0-123456789abc",
"amount": 5000,
"currency": "RUB",
"method": "card",
"gateway": "yookassa",
"idempotency_key": "idem_abc123",
"completed_at": "2026-06-30T14:31:00Z"
}
}
event.cancelled
{
"event": "event.cancelled",
"timestamp": "2026-06-30T15:00:00Z",
"requestId": "req_01912345abcdf1",
"data": {
"id": "01900000-0000-7000-0000-000000000001",
"slug": "tech-conference-2026",
"title": "Tech Conference 2026",
"cancelled_at": "2026-06-30T15:00:00Z",
"reason": "Venue unavailable"
}
}
Signature verification
Each webhook is signed using HMAC-SHA256. Signature verification ensures the request was sent by tikento, not an attacker.
Algorithm
- Retrieve the
X-Tikento-Signatureheader. It has the format:t=<unix_timestamp>,v1=<hex_hmac>. - Parse
t(timestamp) andv1(signature) from the header. - Construct the signing string:
<t>.<raw_body>. - Compute HMAC-SHA256 of this string with your webhook secret.
- Compare the result with
v1using constant-time comparison. - Check that
|now - t| < 300(5 minutes) to prevent replay attacks.
Node.js example
const crypto = require('crypto');
function verifyWebhook(rawBody, signatureHeader, secret) {
// Parse header: "t=1698300000,v1=abc123..."
const parts = Object.fromEntries(
signatureHeader.split(',').map(p => p.split('=', 2))
);
const timestamp = parts.t;
const receivedSig = parts.v1;
// Check timestamp (reject if older than 5 minutes)
const age = Math.abs(Math.floor(Date.now() / 1000) - Number(timestamp));
if (age > 300) throw new Error('Webhook timestamp too old');
// Compute expected signature
const expected = crypto
.createHmac('sha256', secret)
.update(`${timestamp}.${rawBody}`)
.digest('hex');
// Constant-time comparison
return crypto.timingSafeEqual(
Buffer.from(expected),
Buffer.from(receivedSig)
);
}
Python example
import hmac
import hashlib
import time
def verify_webhook(raw_body: str, signature_header: str, secret: str) -> bool:
# Parse header: "t=1698300000,v1=abc123..."
parts = dict(p.split("=", 1) for p in signature_header.split(","))
timestamp = parts["t"]
received_sig = parts["v1"]
# Check timestamp (reject if older than 5 minutes)
age = abs(int(time.time()) - int(timestamp))
if age > 300:
raise ValueError("Webhook timestamp too old")
# Compute expected signature
payload = f"{timestamp}.{raw_body}"
expected = hmac.new(
secret.encode(), payload.encode(), hashlib.sha256
).hexdigest()
return hmac.compare_digest(expected, received_sig)
Replay attack protection
Check the X-Tikento-Timestamp: if it is older than 5 minutes, reject the request. This prevents reuse of intercepted webhooks.
Retry policy
If your endpoint does not respond with HTTP 2xx, tikento retries delivery:
| Attempt | Delay |
|---|---|
| 1 | Immediately |
| 2 | After 1 minute |
| 3 | After 5 minutes |
| 4 | After 30 minutes |
If all 4 attempts (initial + 3 retries) are unsuccessful, the event is marked as failed. You will see a list of failed webhooks in Settings - Integrations - Delivery history.
What counts as success
- HTTP 200, 201, 202, 204 -- delivery is considered successful.
- Timeout: a response must be received within 10 seconds.
What counts as an error
- HTTP 4xx (except 410) -- retry, possible issue on the receiver's side.
- HTTP 5xx -- retry with delay.
- Timeout (no response within 10 seconds) -- retry.
- HTTP 410 (Gone) -- the webhook is automatically disabled, no retries.
Deduplication
Due to retries, your endpoint may receive the same event multiple times. Use requestId from the payload for deduplication:
- When receiving a webhook, check if you have already processed this
requestId. - If yes -- return HTTP 200 without reprocessing.
- If no -- process and save the
requestId.
Recommendations
Quick response
Send HTTP 200 immediately upon receiving the request. Perform long-running processing asynchronously (queue, background task). This reduces the risk of timeouts and retries.
Idempotency
Design your handler so that reprocessing the same event does not cause duplicate actions (double email sends, duplicate charges, etc.).
Logging
Save the requestId, X-Tikento-Event, and timestamp of each received webhook. This helps with debugging and when contacting support.
Security
- Accept webhooks only over HTTPS.
- Always verify the signature via HMAC-SHA256.
- Check the timestamp for replay attack protection.
- Store the webhook secret in environment variables, not in code.