Node.js SDK

npm install @hostwebhook/node

import { verify, parseHeaders } from '@hostwebhook/node';

// Verify the signature (throws VerificationError if invalid)
verify(rawBody, req.headers, process.env.SIGNING_SECRET!);

// Parse all X-HostWebhook-* headers into a typed object
const { eventId, attempt, chainStep } = parseHeaders(req.headers);

import express from 'express';
import { expressMiddleware } from '@hostwebhook/node';

const app = express();

app.post(
  '/webhooks',
  express.raw({ type: 'application/json' }),
  expressMiddleware(process.env.SIGNING_SECRET!),
  (req, res) => {
    const payload = JSON.parse(req.body.toString());
    console.log('Received webhook:', payload);
    res.status(200).json({ received: true });
  },
);

app.listen(3000);

import { Controller, Post, Req, Res, UseGuards, RawBodyRequest } from '@nestjs/common';
import { createNestGuard } from '@hostwebhook/node';
import { Request, Response } from 'express';

const WebhookGuard = createNestGuard(process.env.SIGNING_SECRET!);

@Controller('webhooks')
export class WebhookController {
  @Post()
  @UseGuards(WebhookGuard)
  handleWebhook(@Req() req: RawBodyRequest<Request>, @Res() res: Response) {
    const payload = JSON.parse(req.rawBody!.toString());
    console.log('Received webhook:', payload);
    return res.json({ received: true });
  }
}

import Fastify from 'fastify';
import { fastifyHook } from '@hostwebhook/node';

const app = Fastify();

// Parse JSON as buffer for raw body access
app.addContentTypeParser(
  'application/json',
  { parseAs: 'buffer' },
  (req, body, done) => done(null, body),
);

app.post('/webhooks', {
  preHandler: fastifyHook(process.env.SIGNING_SECRET!),
}, (req, reply) => {
  const payload = JSON.parse((req.body as Buffer).toString());
  console.log('Received webhook:', payload);
  reply.send({ received: true });
});

app.listen({ port: 3000 });

import { NextRequest, NextResponse } from 'next/server';
import { verify, parseHeaders } from '@hostwebhook/node';

export async function POST(req: NextRequest) {
  const rawBody = await req.text();

  try {
    verify(rawBody, Object.fromEntries(req.headers), process.env.SIGNING_SECRET!);
  } catch (err) {
    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
  }

  const { eventId, attempt } = parseHeaders(Object.fromEntries(req.headers));
  const payload = JSON.parse(rawBody);

  console.log(`Event ${eventId} (attempt ${attempt}):`, payload);
  return NextResponse.json({ received: true });
}

import crypto from 'crypto';

function verifyWebhook(rawBody: string, headers: Record<string, string>, secret: string): boolean {
  const sig = headers['x-hostwebhook-signature'];
  if (!sig) return false;

  const parts = Object.fromEntries(
    sig.split(',').map(p => p.trim().split('=', 2) as [string, string]),
  );
  const { t, v1 } = parts;
  if (!t || !v1) return false;

  const expected = crypto.createHmac('sha256', secret).update(`${t}.${rawBody}`).digest('hex');
  const expectedBuf = Buffer.from(expected, 'hex');
  const receivedBuf = Buffer.from(v1, 'hex');

  if (expectedBuf.length !== receivedBuf.length) return false;
  return crypto.timingSafeEqual(expectedBuf, receivedBuf);
}

import { HostWebhook } from '@hostwebhook/node';

const hw = new HostWebhook({
  token: 'your_ingress_token',  // from webhook settings
});

// Returns immediately with event ID — pipeline runs in background
const { eventId } = await hw.send({
  event: 'order.created',
  data: { orderId: '123', amount: 99.99 },
});

console.log('Event created:', eventId);

const result = await hw.send(
  { event: 'order.created', orderId: '123' },
  { waitForResult: true },
);

console.log(result.syncStatus);  // 200 = delivered, 422 = validation failed, 500 = failed
console.log(result.steps);       // array of pipeline steps
console.log(result.response);    // response body from target URL

const { eventId } = await hw.send(
  { event: 'order.created', orderId: '123' },
  {
    onResult: (result) => {
      // Fires when the pipeline completes (SSE stream in background)
      if (result.awaitingApproval) {
        showToast('Awaiting approval from ' + result.approvalNodeName);
      } else if (result.syncStatus === 200) {
        showToast('Delivered successfully');
      } else {
        showToast('Pipeline failed: ' + result.error);
      }
    },
    onStep: (step) => {
      // Optional: fires for each pipeline node as it executes
      updateProgress(step.nodeName, step.status, step.durationMs);
    },
  },
);
// UI shows "Sent!" immediately here — never blocks

const result = await hw.send({ event: 'order.created', orderId: '123' });

if (result.deduplicated) {
  console.log('Duplicate! Original event:', result.originalEventId);
}

const hw = new HostWebhook({
  token: 'your_ingress_token',
  signingSecret: 'your_incoming_secret',  // HMAC-SHA256 custom format
});

await hw.send({ event: 'user.updated', userId: '456' });
// X-Webhook-Signature: sha256=<hex> is added automatically

// Send multiple webhooks in parallel
const results = await hw.sendBatch([
  { event: 'order.created', orderId: '1' },
  { event: 'order.created', orderId: '2' },
  { event: 'order.created', orderId: '3' },
]);

results.forEach(r => console.log('Event:', r.eventId));

import { send } from '@hostwebhook/node';

await send(
  { token: 'your_ingress_token' },
  { event: 'ping', timestamp: Date.now() },
);

const hw = new HostWebhook({
  token: 'your_token',
  baseUrl: 'https://your-hostwebhook-instance.com',
});

import { HostWebhook, SendError } from '@hostwebhook/node';

const hw = new HostWebhook({ token: 'your_token' });

try {
  await hw.send({ event: 'test' });
} catch (err) {
  if (err instanceof SendError) {
    console.error(`Status: ${err.statusCode}, Body: ${err.responseBody}`);
  }
}

# Step 1: Send webhook
curl -s -X POST https://api.hostwebhook.com/api/in/your_token \
  -H "Content-Type: application/json" \
  -d '{"event": "order.created", "amount": 5000}'

# Response: {"eventId":"abc123","streamToken":"uuid-here"}

# Step 2: Open SSE stream
curl -N "https://api.hostwebhook.com/api/events/abc123/stream?token=uuid-here"

# Output:
# event: step
# data: {"nodeType":"filter","nodeName":"Validate","status":"success","durationMs":12}
#
# event: step
# data: {"nodeType":"transform","nodeName":"Clean","status":"success","durationMs":8}
#
# event: done
# data: {"status":200,"body":{"deliveryStatus":"delivered","statusCode":200,"latencyMs":340}}