SMS Webhooks
Bodek SMS pushes events to your server as they happen: a text arriving on one of your numbers,
someone replying STOP, every delivery-status change of a message you sent, and
every step of a flow (text conversation). You create endpoints on
SMS webhooks or through the API, pick exactly which events each one
wants, and verify a signature on every request.
Manage https://dev.bodek.us/sms-webhooks
API https://sms.bodek.us/api/v1/webhooks
Payloads POST <your URL> Content-Type: application/json
Version 2026-10-25 (sent as X-Bodek-Api-Version and api_version)
- Deliveries are queued and sent out of band — normally within a second, never inside the request that caused them. Your endpoint being slow never slows down a send.
- Answer any
2xxwithin 10 seconds. Anything else is retried (schedule). - Events are at-least-once. Deduplicate on the event
id(evt_…) — see the payload. - Up to 20 endpoints per account; each can watch one number or all of them.
⚠ Opt-out policy — read this before you send
Bodek SMS will not stop sending messages because a recipient sent an
opt-out message. When someone replies STOP, UNSUBSCRIBE,
CANCEL or any other opt-out keyword, Bodek SMS records it and raises a
message.opt_out webhook event. It does not suppress that recipient, it does
not cancel queued messages to them, and it does not reply to them on your behalf. Delivery is
stopped only if and when Bodek administration decides to stop delivery.
The company integrating with Bodek SMS is responsible for receiving these
webhooks and stopping delivery. That means: subscribe at least one active endpoint to
message.opt_out, record the recipient in your own suppression list the moment the
event arrives, and stop sending to them.
Violation of this rule can result in suspension of the Bodek SMS service — for the API key, the number, or the whole account, at Bodek administration's discretion.
Practical consequences of this design, so nothing is a surprise:
A number that replied STOP | still receives everything you queue for it. Nothing is filtered. |
| Messages already queued to them | are still sent. Cancel them yourself with DELETE /v1/messages/{id} while they are queued. |
| Flows and text menus | no keyword is reserved. A flow may trigger on STOP, and a running conversation continues. If you want a flow to acknowledge an opt-out, build that branch yourself. |
| Automatic confirmation texts | none are sent. Bodek SMS never texts your recipients on its own. |
| The record | is kept and readable at GET /v1/opt-outs, and is what Bodek administration reviews if compliance is questioned. Every opt-out payload carries "delivery_blocked_by_bodek": false as a plain restatement of the above. |
You remain responsible for compliance with the TCPA, CTIA messaging principles and your carriers' rules. Bodek SMS gives you the signal; acting on it is yours.
Create an endpoint
In the console: SMS webhooks → Add an endpoint. Or over the API with
a key that has webhooks:write:
curl -X POST https://sms.bodek.us/api/v1/webhooks \
-H "Authorization: Bearer bs_live_…" \
-H "Content-Type: application/json" \
-d '{
"name": "Production listener",
"url": "https://your.app/hooks/bodek-sms",
"events": ["message.received", "message.opt_out", "message.delivered", "message.failed"],
"number_id": 12
}'
{
"ok": true,
"webhook": { "id": "wh_9f3c…", "name": "Production listener", "url": "https://your.app/hooks/bodek-sms",
"active": true, "events": ["message.received","message.opt_out","message.delivered","message.failed"],
"opt_out_keywords": ["stop","stopall",…], "using_default_keywords": {"opt_out": true, …},
"stats": {"queued":0,"delivered":0,"failed":0,"pending":0}, "api_version": "2026-10-25" },
"secret": "whsec_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
}
| Field | Description | |
|---|---|---|
url | required | An https:// URL on a publicly reachable host. Checked when you save it and again on every delivery. |
events | required | Event names, or a family: message.*, flow.*, *. |
name | optional | Your label (≤ 120 chars). |
number_id | optional | Only events for this number. Omit for every number on the account. |
active | optional | Default true. A paused endpoint keeps queueing events and sends them when you switch it back on. |
include_body | optional | Default true. false sends body: null on every message — for platforms that must not receive message text. |
keywords | optional | Your own trigger words for message.keyword. |
optout_keywordsoptin_keywordshelp_keywords | optional | Override the platform lists for this endpoint. See Keyword lists. |
headers | optional | Up to 5 extra request headers, e.g. {"X-My-Token": "…"}. X-Bodek-* is reserved. |
The secret is returned once, here and in the console. Store it — it signs every
payload. Rotate it with POST /v1/webhooks/{id}/rotate_secret.
Queues a webhook.test event so you can check the whole path, including your
signature check, before any real traffic.
The payload
Every delivery is the same envelope. Only data changes between event types.
POST https://your.app/hooks/bodek-sms
Content-Type: application/json; charset=utf-8
X-Bodek-Event: message.opt_out
X-Bodek-Event-Id: evt_7b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e
X-Bodek-Webhook-Id: wh_9f3c1a2b3c4d5e6f7a8b9c0d1e2f3a4b
X-Bodek-Signature: t=1792000000,v1=5f0c9a…
X-Bodek-Attempt: 1
X-Bodek-Api-Version: 2026-10-25
{
"id": "evt_7b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e",
"type": "message.opt_out",
"api_version": "2026-10-25",
"created_at": "2026-10-25T14:03:11+00:00",
"webhook_id": "wh_9f3c1a2b3c4d5e6f7a8b9c0d1e2f3a4b",
"account_id": 4120,
"data": { … }
}
id | Unique per (event, endpoint). Deduplicate on this. A retry reuses it. |
type | The event name, same as X-Bodek-Event. |
X-Bodek-Attempt | 1 on the first try, 2 on the first retry, and so on. |
api_version | The payload shape. Bumped only when an existing field changes meaning. |
Order is not guaranteed. message.delivered can arrive before
message.sent if a retry delayed one of them. Treat the message's
delivery block and its timestamps as the truth, not the arrival order.
Verifying the signature
X-Bodek-Signature is t=<unix seconds>,v1=<hex> where the hex is
HMAC-SHA256(secret, "<t>.<raw request body>"). Hash the raw
body, before any JSON parsing or re-encoding. Reject anything older than ~5 minutes to
stop replays, and compare in constant time.
// PHP
$raw = file_get_contents('php://input');
$sig = $_SERVER['HTTP_X_BODEK_SIGNATURE'] ?? '';
$secret = getenv('BODEK_SMS_WEBHOOK_SECRET');
if (sscanf($sig, 't=%d,v1=%s', $t, $v1) !== 2
|| abs(time() - $t) > 300
|| !hash_equals(hash_hmac('sha256', $t . '.' . $raw, $secret), $v1)) {
http_response_code(400);
exit('bad signature');
}
$event = json_decode($raw, true);
// Answer fast, then do the work: queue it and return 200 immediately.
http_response_code(200);
// Node (express — note express.raw, not express.json)
app.post('/hooks/bodek-sms', express.raw({ type: 'application/json' }), (req, res) => {
const m = /^t=(\d+),v1=([0-9a-f]+)$/.exec(req.get('X-Bodek-Signature') || '');
if (!m) return res.status(400).end();
const [, t, v1] = m;
if (Math.abs(Date.now() / 1000 - Number(t)) > 300) return res.status(400).end();
const mac = crypto.createHmac('sha256', process.env.BODEK_SMS_WEBHOOK_SECRET)
.update(`${t}.${req.body}`).digest('hex');
if (!crypto.timingSafeEqual(Buffer.from(mac), Buffer.from(v1))) return res.status(400).end();
const event = JSON.parse(req.body.toString('utf8'));
res.sendStatus(200);
});
# Python (Flask)
raw = request.get_data()
sig = request.headers.get("X-Bodek-Signature", "")
parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p)
t, v1 = parts.get("t", "0"), parts.get("v1", "")
if abs(time.time() - int(t)) > 300: abort(400)
mac = hmac.new(SECRET.encode(), f"{t}.".encode() + raw, hashlib.sha256).hexdigest()
if not hmac.compare_digest(mac, v1): abort(400)
event = json.loads(raw)
During a secret rotation accept either secret for a few minutes: payloads already queued were signed with the old one.
Event catalogue
Subscribe to exact names, or to a family (message.*, flow.*,
*). GET /v1/webhooks/events returns this list at run time together with
the default keyword lists and the retry schedule.
Inbound messages
message.received | Someone texted one of your numbers (any inbound message). |
message.opt_out | An inbound message matched the opt-out keyword list (STOP, UNSUBSCRIBE, …). |
message.opt_in | An inbound message matched the start/opt-in keyword list (START, YES, …). |
message.help | An inbound message matched the help keyword list (HELP, INFO, …). |
message.keyword | An inbound message matched this endpoint's own keyword list. |
Delivery status
message.queued | A message you sent was accepted and queued. |
message.sending | A queued message was handed to a sending phone. |
message.sent | The message left the phone and the carrier accepted it. |
message.delivered | The carrier confirmed delivery to the handset. |
message.read | The recipient’s handset reported the message as read (MMS/RCS only). |
message.failed | The message could not be sent (retries exhausted or a send error). |
message.bounced | The carrier rejected the message permanently (unreachable, invalid or blocked number). |
message.expired | The message was still queued when its TTL ran out and was never sent. |
message.cancelled | The message was cancelled before it was sent. |
Flows
flow.run.started | A flow run (text conversation) started. |
flow.run.step | A flow run executed a step. |
flow.run.input | The person replied to a flow run. |
flow.run.completed | A flow run finished normally. |
flow.run.expired | A flow run timed out waiting for a reply. |
flow.run.stopped | A flow run was stopped (by you, the API, or because the flow was switched off). |
flow.run.error | A flow run ended in an error. |
flow.updated | A flow was created, changed, activated, paused or deleted. |
Calls (voice)
call.received | An inbound call reached one of your numbers (before it is answered). |
call.answered | A call was answered and a call flow started running. |
call.consent | The recording announcement was played to the caller (carries the exact words and the time). |
call.input | The caller pressed a key in a call flow menu. |
call.forwarded | A call was forwarded or bridged to another number. |
call.recorded | A recording (voicemail or recorded call) is ready to download. |
call.completed | A call flow finished and the call ended. |
call.failed | A call flow could not run or ended in an error. |
call.missed | An inbound call was not answered (rang out, declined or blocked). |
call.unsupported | A call flow needed something the answering number cannot do yet (see `primitive`). |
voice_flow.updated | A call flow was created, changed, activated, paused or deleted. |
Other
webhook.test | A test event you sent yourself from the console or the API. |
Inbound messages
One arriving text can raise several events to the same endpoint — message.received
for the text itself, plus message.opt_out if it matched your opt-out list. Each is a
separate delivery with its own event id, so you can subscribe to the opt-outs alone
and get nothing else:
{ "events": ["message.opt_out"] } // only opt-outs, no other inbound traffic
{ "events": ["message.opt_out", "message.opt_in"] } // stops and starts
{ "events": ["message.received"] } // every inbound, opt-outs included
The data for an inbound event:
{
"message": {
"id": "msg_af6d1cbbb042d08e5ddeef055306fd5a",
"seq": 48122,
"direction": "in",
"from": "+15557654321", // the person who texted you
"to": "+15551230000", // your number
"number_id": 12,
"number": "+15551230000",
"body": "STOP",
"status": "received",
"source": "inbound",
"segments": 1,
"created_at": "2026-10-25T14:03:11+00:00",
"media": [],
"delivery": { "state": "received", "terminal": false, "read": false, "bounced": false }
},
"number": { "id": 12, "number": "+15551230000", "label": "Front desk" },
"group": null, // or {"id": 7, "name": "U12 Team"} if they are in a group
"is_group_member": false,
"keyword_match": "opt_out", // "opt_out" | "opt_in" | "help" | null
"opt_out_state": "opted_out", // "opted_out" | "opted_in" | null
"delivery_stopped_by_bodek": false // always false — see the opt-out policy
}
Picture messages (MMS) arrive with a media list; download each with its
url and the same bearer key. include_body: false on the endpoint sends
"body": null and leaves everything else intact.
Keyword lists
Matching is on the whole message, normalised: lower-cased, trimmed, inner
whitespace collapsed, surrounding punctuation stripped. So "STOP." and
" Stop " match, and "stop by at 5" does not — a sentence is a
conversation, not a command, and treating it as one would produce false opt-outs.
Bodek's default lists:
message.opt_out | stop, stopall, stop all, unsubscribe, unsub, cancel, end, quit, optout, opt out, opt-out, revoke, remove me, no more, delete |
message.opt_in | start, unstop, yes, subscribe, optin, opt in, opt-in, resume, continue |
message.help | help, info, support |
Each endpoint may replace any of these with its own list — useful for another language, a narrower set, or extra words your customers actually use. A list you don't override keeps the platform default, so the two can never disagree:
curl -X PATCH https://sms.bodek.us/api/v1/webhooks/wh_9f3c… \
-H "Authorization: Bearer bs_live_…" -H "Content-Type: application/json" \
-d '{
"optout_keywords": ["stop", "stopall", "unsubscribe", "cancelar", "basta", "no mas"],
"optin_keywords": ["start", "si", "subscribe"],
"keywords": ["BOOK", "QUOTE", "HOURS"]
}'
Up to 40 keywords per list, 40 characters each. Send null to go back to the
platform default. Overriding a list changes which events you are told about — it does
not change what Bodek records, and it never changes what Bodek delivers.
message.keyword uses your own keywords list and is independent of the
three above, so BOOK can route to your booking system while
message.opt_out keeps feeding your suppression list.
Delivery status
Every message you send reports its whole life. Subscribe to the ones you care about, or to
message.* for all of them. Each status fires at most once per
message — a re-queued send, a duplicated phone report or a repeated maintenance pass
cannot produce a second copy.
| Event | Means | Final? |
|---|---|---|
message.queued | Accepted and waiting for a sending phone. | no |
message.sending | Handed to a phone. from is now the real sending number. | no |
message.sent | Left the phone; the carrier accepted it. | no |
message.delivered | The carrier confirmed delivery to the handset. | yes |
message.read | The handset returned a read report. MMS/RCS only — plain SMS has no read receipts, so most messages never fire this. | yes |
message.bounced | Permanently rejected: the number is invalid, not in service, unreachable, blocked, or outside the US/Canada. Retrying will never work. | yes |
message.failed | Could not be sent for a reason that might not repeat (no signal, a generic carrier error, no result from the phone). Already retried internally before you hear about it. | yes |
message.expired | Still queued when its ttl ran out; never sent. | yes |
message.cancelled | You cancelled it with DELETE /v1/messages/{id} before it was sent. | yes |
The data is the full message plus, on a failure, why:
{
"message": {
"id": "msg_af6d1cbbb042d08e5ddeef055306fd5a",
"seq": 48125,
"direction": "out",
"from": "+15551230000", // your sending number
"to": "+15557654321", // the recipient
"number_id": 12,
"body": "Your table is ready!",
"status": "delivered",
"source": "api",
"segments": 1,
"attempts": 1,
"client_ref": "order-8412", // your own reference, echoed back
"api_key_id": 31, // which key sent it
"error": null,
"created_at": "2026-10-25T14:03:11+00:00", // accepted / queued
"send_after": null,
"expires_at": "2026-10-26T14:03:11+00:00",
"sent_at": "2026-10-25T14:03:14+00:00", // left the phone
"delivered_at": "2026-10-25T14:03:19+00:00", // carrier receipt
"read_at": null,
"updated_at": "2026-10-25T14:03:19+00:00",
"media": [],
"delivery": { "state": "delivered", "terminal": true, "read": false, "bounced": false },
"failure_code": null, // present on failed / bounced / expired
"failure_type": null // "permanent" | "transient" | "expired"
}
}
client_ref is the field to key on: set it when you send and every status event for
that message carries it back, so you never have to store our ids to match a status to your own
record.
Flow events
Flows (text menus and automations) report every step, so a platform that builds flows through the Flows API can follow a conversation live instead of polling the run.
flow.run.started | A conversation began (missed call, keyword, any text, or your API call). |
flow.run.step | One step ran: a reply sent, a menu choice taken, an answer saved, an API step called, a branch evaluated, a staff alert sent. |
flow.run.input | The person replied. |
flow.run.completed | The conversation finished normally. |
flow.run.expired | No reply within the flow's timeout. |
flow.run.stopped | Stopped by you, by the API, or because the flow was switched off. |
flow.run.error | The run ended in an error. |
flow.updated | A flow was created, changed, activated, paused or deleted — whether from the API or the editor. |
{
"run": {
"id": 431, "flow_id": 5, "number_id": 12, "to": "+15557654321",
"trigger": "keyword", "status": "active", "waiting_on_step": "ask_order",
"messages_sent": 2, "steps": 3,
"vars": { "name": "Ann", "order": "10442" },
"started_at": "…", "updated_at": "…", "expires_at": "…"
},
"flow": { "id": 5, "name": "Front desk", "number_id": 12, "number": "+15551230000" },
"step": { "id": "ask_order", "kind": "answer", "detail": "order = 10442" },
"caller": "+15557654321",
"vars": { "name": "Ann", "order": "10442" }
}
step.kind is one of start, reply, choice,
answer, invalid, set, branch,
webhook, notify, ring, join_group,
input, error, end. A flow's own
API step is a different thing — a request your flow makes mid-conversation,
whose reply steers it; see Flows → API steps.
Pulling message details
Webhooks push; the API lets you pull the same facts whenever you want — every message a platform sent, both numbers, the text, the segment count, which key sent it and every timestamp it passed through.
# Everything this key sent yesterday, with delivery status
curl -G https://sms.bodek.us/api/v1/messages \
-H "Authorization: Bearer bs_live_…" \
--data-urlencode "direction=out" \
--data-urlencode "source=api" \
--data-urlencode "sent_after=2026-10-24T00:00:00Z" \
--data-urlencode "sent_before=2026-10-25T00:00:00Z" \
--data-urlencode "limit=200"
# One message by your own reference
curl -G https://sms.bodek.us/api/v1/messages --data-urlencode "client_ref=order-8412" \
-H "Authorization: Bearer bs_live_…"
# One message by its secure id
curl https://sms.bodek.us/api/v1/messages/msg_af6d1cbbb042d08e5ddeef055306fd5a \
-H "Authorization: Bearer bs_live_…"
| Filter | Description |
|---|---|
direction | in or out. |
status | queued, sending, sent, delivered, failed, received, cancelled, expired. |
read=1 | Only messages with a read receipt. |
phone | The other party's number. |
number_id | One of your numbers. |
client_ref | Your own reference, exactly as you sent it. |
source | api, web, group, flow, inbound, phone, call, command. |
created_after / created_beforesent_after / sent_before | ISO-8601 timestamps or unix seconds. |
since_id / before_id / limit | Paging, on the seq cursor. limit max 200. |
Secure message ids
Every message has an opaque id, msg_ plus 32 hex characters, generated from a
CSPRNG. That is the id in every API response and every webhook payload, and it is
what /v1/messages/{id} takes — so an id can be logged, passed between systems or
put in a support ticket without exposing how much traffic anyone sends, and no one can walk
your message history by counting. The database row number is still returned as
seq, because since_id and before_id page on it.
/v1/messages/{id} accepts either form.
Needs webhooks:read. The delivery audit trail for one message: every webhook event
we raised about it, to which endpoint, with the payload we sent, the HTTP status we got back and
how many attempts it took. This is the record to check when an integration claims it was never
told about an opt-out.
The opt-out record
Needs optouts:read. Everyone who has sent an opt-out (or opt-in) keyword to your
numbers. This is a record, not a block list — read
the opt-out policy.
curl -G https://sms.bodek.us/api/v1/opt-outs \
-H "Authorization: Bearer bs_live_…" \
--data-urlencode "state=opted_out" \
--data-urlencode "since=2026-10-01T00:00:00Z"
{
"ok": true,
"opt_outs": [
{ "phone": "+15557654321", "number_id": 12, "number": "+15551230000",
"state": "opted_out", "keyword": "stop",
"opted_out_at": "2026-10-25T14:03:11+00:00", "opted_in_at": null,
"updated_at": "2026-10-25T14:03:11+00:00",
"delivery_blocked_by_bodek": false }
],
"policy": "Delivery is not blocked by these records. Suppress these recipients in your own system."
}
Query: state (opted_out/opted_in), since,
number_id, phone, limit (max 500), offset.
Reconcile this list against your own suppression list on a schedule — a webhook your server was
down for is still recorded here.
One number's state across your numbers.
Needs messages:send. Records an opt-out (or opt-in) you collected elsewhere — a
web form, a phone call, an email — so the record Bodek administration reviews matches what you
actually know. It never sends a message, and like every other row here it blocks nothing.
curl -X POST https://sms.bodek.us/api/v1/opt-outs \
-H "Authorization: Bearer bs_live_…" -H "Content-Type: application/json" \
-d '{ "phone": "+15557654321", "number_id": 12, "state": "opted_out", "keyword": "web form" }'
Retries & the delivery log
A delivery is attempted straight away. Anything that is not a 2xx — a timeout, a
5xx, a redirect (we don't follow them), a body over 64 KB — is retried on this
schedule until a 2xx arrives or 10 attempts are
used, about 22 hours in all:
10s → 30s → 1m → 5m → 15m → 30m → 1h → 2h → 6h → 12h
404or410stops the retries immediately — we take it to mean the URL is gone. Fix the URL and useretry_failed.- A paused endpoint doesn't lose events: they wait and go out when you switch it on.
- An endpoint with more than 20,000 events waiting starts
droppeding new ones, with the reason recorded. A dropped delivery keeps no payload and cannot be retried. - Nothing is ever auto-disabled for failing. An endpoint that stops receiving opt-outs because we switched it off would be worse than one that keeps retrying.
The log, kept 30 days: each attempt's status, HTTP code, timing,
the first 500 bytes of your response, and the exact payload we sent. Query:
status, event, message_id, before_id,
limit.
{"ok": true, "webhook_id": "wh_9f3c…", "deliveries": [{
"id": "evt_7b1c…", "event": "message.opt_out", "status": "delivered",
"attempts": 2, "http_status": 200, "response_ms": 142, "response_body": "{\"ok\":true}",
"error": null, "message_id": 48122, "phone": "+15557654321",
"next_attempt_at": null,
"created_at": "2026-10-25T14:03:11+00:00", "delivered_at": "2026-10-25T14:03:42+00:00",
"payload": { … exactly what we POSTed … }
}]}
Replay one delivery, or every failed one, after you've fixed your end. Your handler must be
idempotent anyway — dedupe on the event id.
Managing endpoints via API
| Endpoint | Scope | Purpose |
|---|---|---|
GET /v1/webhooks/events | — | Event catalogue, default keywords, retry schedule, the opt-out policy in one line. |
GET /v1/webhooks | webhooks:read | Your endpoints, with delivery stats. |
POST /v1/webhooks | webhooks:write | Create one; the secret is returned once. |
GET /v1/webhooks/{id} | webhooks:read | One endpoint, including its secret. |
PATCH /v1/webhooks/{id} | webhooks:write | Change any subset of its fields. |
DELETE /v1/webhooks/{id} | webhooks:write | Delete it and its log; queued events are discarded. |
POST /v1/webhooks/{id}/test | webhooks:write | Queue a webhook.test event (10/min per endpoint). |
POST /v1/webhooks/{id}/rotate_secret | webhooks:write | New signing secret. |
GET /v1/webhooks/{id}/deliveries | webhooks:read | The delivery log. |
GET /v1/messages/{id}/events | webhooks:read | Every event raised about one message. |
GET /v1/opt-outs | optouts:read | The opt-out record. |
Endpoint ids are opaque (wh_ + 32 hex). A key bound to one number can only create
and see endpoints for that number. Webhook writes are rate-limited to 30/min per account.
Security
- Always verify the signature. Your URL is reachable by anyone; the signature is what makes a request ours. Reject unsigned and stale requests.
- Where we will and won't connect. Only
https://(plainhttp://is refused), only hosts that resolve entirely to public addresses — no loopback, private, link-local, CGNAT, multicast or cloud-metadata ranges, and not this server's own addresses. The connection is pinned to the address we checked, so a DNS answer cannot change between the check and the connect. Redirects are never followed and responses are capped at 64 KB. - Credentials belong in a header, not in the URL — a URL with
user:pass@is refused. Add up to 5 of your own headers; values are write-only once saved. - Answer fast. 10-second timeout. Acknowledge with
200, then do the work in a queue. - Be idempotent. At-least-once delivery, unordered. Dedupe on the event
id. - Rotate on exposure. If a secret leaks, rotate it; accept both for a few minutes.
- Don't put message text where you shouldn't.
include_body: falsesendsbody: nullif your platform must not receive it.
Questions, or a suspension to appeal: quote the
X-Request-Id of an API call or an event id from the delivery log.