Events feed

# First page. Keep the response to read next_cursor from it.
PAGE=$(curl -sS -G https://api.isnap.ai/v1/webhooks/events \
  -H "Authorization: Bearer $ISNAP_API_KEY" \
  --data-urlencode "since=2026-10-08T12:00:00Z" \
  --data-urlencode "limit=100")
echo "$PAGE"
NEXT_CURSOR=$(echo "$PAGE" | jq -r '.data.next_cursor // empty')

# Next page, only when there is one: the same filters, and the cursor of the previous page.
if [ -n "$NEXT_CURSOR" ]; then
  curl -sS -G https://api.isnap.ai/v1/webhooks/events \
    -H "Authorization: Bearer $ISNAP_API_KEY" \
    --data-urlencode "since=2026-10-08T12:00:00Z" \
    --data-urlencode "limit=100" \
    --data-urlencode "cursor=$NEXT_CURSOR"
fi

import { ISnapClient, type WebhookEventItem } from '@isnap/sdk'

const client = new ISnapClient({ apiKey: process.env.ISNAP_API_KEY ?? '', maxRetries: 2 })
const OVERLAP_MS = 10 * 60 * 1000

// Replace these two with your own storage: the same store of processed event ids as your
// receiver, and the start time of the previous poll.
const processed = new Set<string>()
let previousPollStartedAt = new Date(Date.now() - 60 * 60 * 1000)

async function catchUp (): Promise<void> {
  const startedAt = new Date()
  const since = new Date(previousPollStartedAt.getTime() - OVERLAP_MS).toISOString()

  // The iterator fetches every page of the window, newest event first.
  const missed: WebhookEventItem[] = []
  for await (const event of client.webhooks.events({ since, limit: 100 })) {
    if (!processed.has(event.event_id)) missed.push(event)
  }

  // Process the oldest event first.
  for (const event of missed.reverse()) {
    handle(event)
    processed.add(event.event_id)
  }
  // Move the window only after a complete walk.
  previousPollStartedAt = startedAt
}

function handle (event: WebhookEventItem): void {
  switch (event.event_type) {
    case 'message.received':
      console.log('inbound message', event.event_id)
      break
    default:
      // An event type you do not handle, or do not know: count it as processed and skip it.
      break
  }
}

await catchUp()

import os
import time
from datetime import datetime, timedelta, timezone

import requests

API = "https://api.isnap.ai"
HEADERS = {"Authorization": f"Bearer {os.environ['ISNAP_API_KEY']}"}
OVERLAP = timedelta(minutes=10)

# Replace these two with your own storage: the same store of processed event ids as your
# receiver, and the start time of the previous poll.
processed = set()
previous_poll_started_at = datetime.now(timezone.utc) - timedelta(hours=1)


def get(path, params):
    """A read. Retries a 429 after Retry-After seconds, and a 500 or a 503 up to 2 times."""
    failures = 0
    while True:
        response = requests.get(f"{API}{path}", headers=HEADERS, params=params, timeout=30)
        if response.status_code == 429:
            time.sleep(int(response.headers.get("Retry-After", "60")))
            continue
        if response.status_code in (500, 503) and failures < 2:
            failures += 1
            time.sleep(2**failures)
            continue
        response.raise_for_status()
        return response.json()["data"]


def catch_up():
    global previous_poll_started_at
    started_at = datetime.now(timezone.utc)
    since = (previous_poll_started_at - OVERLAP).strftime("%Y-%m-%dT%H:%M:%SZ")

    # Walk every page of the window, newest event first. Send the same filters on every page.
    params = {"since": since, "limit": 100}
    missed = []
    while True:
        page = get("/v1/webhooks/events", params)
        missed.extend(event for event in page["items"] if event["event_id"] not in processed)
        if not page["has_more"]:
            break
        params["cursor"] = page["next_cursor"]

    # Process the oldest event first.
    for event in reversed(missed):
        handle(event)
        processed.add(event["event_id"])
    # Move the window only after a complete walk.
    previous_poll_started_at = started_at


def handle(event):
    if event["event_type"] == "message.received":
        print("inbound message", event["event_id"])
    # An event type you do not handle, or do not know: count it as processed and skip it.


catch_up()