completion webhooks

curl -X POST https://api.crawlbrulee.com/api/scrape/async \
  -H "Authorization: Bearer $CRAWLBRULEE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "extract": { "markdown": true },
    "webhook": {
      "url": "https://your-app.com/hooks/crawlbrulee",
      "metadata": { "order_id": "A-1234" }
    }
  }'

await fetch('https://api.crawlbrulee.com/api/scrape/async', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.CRAWLBRULEE_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    url: 'https://example.com',
    extract: { markdown: true },
    webhook: {
      url: 'https://your-app.com/hooks/crawlbrulee',
      metadata: { order_id: 'A-1234' },
    },
  }),
})

import { Crawlbrulee } from '@crawlbrulee/sdk'
 
// reads CRAWLBRULEE_API_KEY from the environment
const crawlbrulee = Crawlbrulee.fromEnv()
 
await crawlbrulee.scrapeAsync({
  url: 'https://example.com',
  extract: { markdown: true },
  webhook: {
    url: 'https://your-app.com/hooks/crawlbrulee',
    metadata: { order_id: 'A-1234' },
  },
})

requests.post(
    "https://api.crawlbrulee.com/api/scrape/async",
    headers={
        "Authorization": f"Bearer {os.environ['CRAWLBRULEE_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "url": "https://example.com",
        "extract": {"markdown": True},
        "webhook": {
            "url": "https://your-app.com/hooks/crawlbrulee",
            "metadata": {"order_id": "A-1234"},
        },
    },
)

from crawlbrulee import Crawlbrulee, ScrapeExtract
 
# reads CRAWLBRULEE_API_KEY from the environment
client = Crawlbrulee.from_env()
 
client.scrape_async(
    url="https://example.com",
    extract=ScrapeExtract(markdown=True),
    webhook={
        "url": "https://your-app.com/hooks/crawlbrulee",
        "metadata": {"order_id": "A-1234"},
    },
)

import express from 'express'
import { verifyWebhookSignature } from '@crawlbrulee/sdk'
 
const app = express()
const seen = new Set() // use a real store (Redis, db) in production
const SECRET = process.env.CRAWLBRULEE_WEBHOOK_SECRET
 
// capture the RAW body — required for signature verification
app.post('/hooks/crawlbrulee', express.raw({ type: 'application/json' }), async (req, res) => {
  const rawBody = req.body.toString('utf8')
 
  const result = await verifyWebhookSignature({
    payload: rawBody,
    headers: req.headers,
    secret: SECRET,
  })
  if (!result.verified) {
    return res.status(401).send('bad signature')
  }
 
  const event = JSON.parse(rawBody)
 
  // ack immediately, then process out of band
  res.status(200).send('ok')
 
  if (seen.has(event.event_id)) return // already handled
  seen.add(event.event_id)
 
  if (event.data.status === 'success') {
    void handleResult(event.data.job_id, event.data.metadata)
  }
})

import os
 
from flask import Flask, request
from crawlbrulee import verify_webhook_signature
 
app = Flask(__name__)
seen = set()  # use a real store (Redis, db) in production
SECRET = os.environ["CRAWLBRULEE_WEBHOOK_SECRET"]
 
 
@app.post("/hooks/crawlbrulee")
def crawlbrulee_webhook():
    raw_body = request.get_data()  # raw bytes — required for verification
 
    result = verify_webhook_signature(
        payload=raw_body,
        headers=dict(request.headers),
        secret=SECRET,
    )
    if not result.verified:
        return "bad signature", 401
 
    event = request.get_json()
    event_id = event["event_id"]
 
    if event_id not in seen:  # idempotency
        seen.add(event_id)
        if event["data"]["status"] == "success":
            # in production, enqueue this instead of processing inline —
            # Flask can't ack before the view function returns
            handle_result(event["data"]["job_id"], event["data"].get("metadata"))
 
    return "ok", 200