Webhooks

# Queue a Stripe webhook event
curl -X POST https://api.spooled.cloud/api/v1/jobs \
  -H "Authorization: Bearer sp_live_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "queue_name": "stripe-events",
    "payload": {
      "id": "evt_1234",
      "type": "invoice.paid",
      "data": {"object": {...}}
    },
    "idempotency_key": "evt_1234"
  }'

import { SpooledClient } from '@spooled/sdk';

const client = new SpooledClient({
  apiKey: process.env.SPOOLED_API_KEY!,
});

// Express.js webhook handler
app.post('/webhooks/stripe', async (req, res) => {
  const sig = req.headers['stripe-signature'];
  
  try {
    // Verify and parse the webhook
    const event = stripe.webhooks.constructEvent(
      req.body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET
    );
    
    // Queue in Spooled for reliable processing
    await client.jobs.create({
      queueName: 'stripe-events',
      payload: event,
      idempotencyKey: event.id,
    });
    
    // Return 200 immediately - Spooled handles retries
    res.status(200).send('Queued');
  } catch (error) {
    res.status(400).send(`Webhook Error: ${error.message}`);
  }
});

from flask import Flask, request
from spooled import SpooledClient
import stripe
import os

app = Flask(__name__)
client = SpooledClient(api_key=os.environ["SPOOLED_API_KEY"])

@app.route('/webhooks/stripe', methods=['POST'])
def handle_stripe_webhook():
    payload = request.data
    sig = request.headers.get('Stripe-Signature')
    
    try:
        event = stripe.Webhook.construct_event(
            payload, sig, os.environ['STRIPE_WEBHOOK_SECRET']
        )
        
        # Queue in Spooled for reliable processing
        client.jobs.create({
            "queue_name": "stripe-events",
            "payload": event,
            "idempotency_key": event['id']
        })
        
        return 'Queued', 200
    except Exception as e:
        return f'Webhook Error: {str(e)}', 400

import (
	"context"
	"net/http"
	"github.com/spooled-cloud/spooled-sdk-go/spooled"
	"github.com/spooled-cloud/spooled-sdk-go/spooled/resources"
)

client, _ := spooled.NewClient(spooled.WithAPIKey("sp_live_YOUR_API_KEY"))

// HTTP handler for Stripe webhooks
http.HandleFunc("/webhooks/stripe", func(w http.ResponseWriter, r *http.Request) {
	event, _ := stripe.ConstructEvent(r.Body, r.Header.Get("Stripe-Signature"), webhookSecret)
	
	// Queue in Spooled for reliable processing
	client.Jobs().Create(context.Background(), &resources.CreateJobRequest{
		QueueName:      "stripe-events",
		Payload:        event,
		IdempotencyKey: stringPtr(event.ID),
	})
	
	w.WriteHeader(http.StatusOK)
})

<?php

use Spooled\SpooledClient;
use Spooled\Config\ClientOptions;

$client = new SpooledClient(new ClientOptions(
    apiKey: getenv('SPOOLED_API_KEY'),
));

// Slim/Laravel webhook handler
$app->post('/webhooks/stripe', function ($request, $response) use ($client) {
    $sig = $request->getHeaderLine('Stripe-Signature');
    $payload = (string) $request->getBody();
    
    $event = \Stripe\Webhook::constructEvent(
        $payload, $sig, getenv('STRIPE_WEBHOOK_SECRET')
    );
    
    // Queue in Spooled for reliable processing
    $client->jobs->create([
        'queue' => 'stripe-events',
        'payload' => $event->toArray(),
        'idempotencyKey' => $event->id,
    ]);
    
    return $response->withStatus(200);
});

import { SpooledClient, SpooledWorker } from '@spooled/sdk';

const client = new SpooledClient({
  apiKey: process.env.SPOOLED_API_KEY!,
});

// Worker to process Stripe events
const worker = new SpooledWorker(client, {
  queueName: 'stripe-events',
});

worker.process(async (ctx) => {
  const event = ctx.payload;
  
  switch (event.type) {
    case 'invoice.paid':
      await handleInvoicePaid(event.data.object);
      break;
    case 'customer.subscription.updated':
      await handleSubscriptionUpdate(event.data.object);
      break;
    case 'payment_intent.succeeded':
      await handlePaymentSuccess(event.data.object);
      break;
    default:
      console.log(`Unhandled event type: ${event.type}`);
  }
  
  return { processed: true };
});

await worker.start();

from spooled import SpooledClient
from spooled.worker import SpooledWorker

client = SpooledClient(api_key=os.environ["SPOOLED_API_KEY"])
worker = SpooledWorker(client, queue_name="stripe-events")

@worker.process
def handle_stripe_event(ctx):
    event = ctx.payload
    event_type = event.get("type")
    
    if event_type == "invoice.paid":
        handle_invoice_paid(event["data"]["object"])
    elif event_type == "customer.subscription.updated":
        handle_subscription_update(event["data"]["object"])
    elif event_type == "payment_intent.succeeded":
        handle_payment_success(event["data"]["object"])
    else:
        print(f"Unhandled event type: {event_type}")
    
    return {"processed": True}

worker.start()

<?php

use Spooled\SpooledClient;
use Spooled\Config\ClientOptions;
use Spooled\Worker\SpooledWorker;
use Spooled\Worker\WorkerConfig;
use Spooled\Worker\JobContext;

$client = new SpooledClient(new ClientOptions(
    apiKey: getenv('SPOOLED_API_KEY'),
));

$worker = new SpooledWorker($client, new WorkerConfig(
    queueName: 'stripe-events',
));

$worker->process(function (JobContext $ctx): array {
    $event = $ctx->payload;
    $eventType = $event['type'] ?? '';
    
    match ($eventType) {
        'invoice.paid' => handleInvoicePaid($event['data']['object']),
        'customer.subscription.updated' => handleSubscriptionUpdate($event['data']['object']),
        'payment_intent.succeeded' => handlePaymentSuccess($event['data']['object']),
        default => error_log("Unhandled event type: {$eventType}"),
    };
    
    return ['processed' => true];
});

$worker->start();

import { SpooledClient } from '@spooled/sdk';

const client = new SpooledClient({
  apiKey: process.env.SPOOLED_API_KEY!,
});

// GitHub webhook handler
app.post('/webhooks/github', async (req, res) => {
  const event = req.headers['x-github-event'];
  const delivery = req.headers['x-github-delivery'];
  
  // Queue for processing
  await client.jobs.create({
    queueName: 'github-events',
    payload: {
      event,
      data: req.body,
    },
    idempotencyKey: delivery, // Use delivery ID for deduplication
  });
  
  res.status(200).send('Queued');
});

from flask import Flask, request
from spooled import SpooledClient

app = Flask(__name__)
client = SpooledClient(api_key=os.environ["SPOOLED_API_KEY"])

@app.route('/webhooks/github', methods=['POST'])
def handle_github_webhook():
    event = request.headers.get('X-GitHub-Event')
    delivery = request.headers.get('X-GitHub-Delivery')
    
    # Queue for processing
    client.jobs.create({
        "queue_name": "github-events",
        "payload": {
            "event": event,
            "data": request.json
        },
        "idempotency_key": delivery  # Deduplication
    })
    
    return 'Queued', 200

<?php

use Spooled\SpooledClient;
use Spooled\Config\ClientOptions;

$client = new SpooledClient(new ClientOptions(
    apiKey: getenv('SPOOLED_API_KEY'),
));

// Slim/Laravel webhook handler
$app->post('/webhooks/github', function ($request, $response) use ($client) {
    $event = $request->getHeaderLine('X-GitHub-Event');
    $delivery = $request->getHeaderLine('X-GitHub-Delivery');
    $payload = json_decode((string) $request->getBody(), true);
    
    // Queue for processing
    $client->jobs->create([
        'queue' => 'github-events',
        'payload' => [
            'event' => $event,
            'data' => $payload,
        ],
        'idempotencyKey' => $delivery, // Deduplication
    ]);
    
    return $response->withStatus(200);
});