Use Case

Queue form submissions and process asynchronously

Form tools expect a fast response-even if your CRM or email provider is slow. Hooque queues every submission so leads never get dropped.

The Challenge

Do not lose submissions; queue them and process them reliably. Typeform, Jotform, and Google Forms leads all need the same durable flow.

Form tools send webhooks with tight timeouts.

Inline processing (DB + CRM + email) causes timeouts when any service is slow.

A lost submission is a lost customer.

How Hooque Solves It

Capture every submission instantly, then process in the background with simple REST consumption.

Provider

Typeform / Jotform

submissions - leads

Buffer

Hooque

Durable lead queue

Consume

Lead processor

REST pull

  • Zero lost submissions: every lead is persisted before processing.
  • Simple REST consumption: pull messages with a single endpoint.
  • No infrastructure overhead: no queue cluster, no retry code, no cron glue.

Before & After

Stop doing slow CRM/email work inside the webhook request. Pull and process reliably.

Without Hooque

Inline processing causes timeouts and lost leads

// Typeform webhook verification + processing inline
import express from "express";

const app = express();
app.use(express.json());

// Public webhook endpoint: where should we host it so form providers can always reach it?
app.post("/typeform/webhook", async (req, res) => {
  const signature = req.get("typeform-signature");
  // This signature check is often forgotten when shipping quickly.
  if (!verifyTypeformSignature(req.rawBody, signature, process.env.TYPEFORM_WEBHOOK_SECRET)) {
    return res.status(401).send("invalid signature");
  }

  try {
    // Hope we do not timeout while processing inline.
    await process_form_payload(req.body); // form_response
    res.sendStatus(200);
  } catch (err) {
    // Do we need to send an alert here?
    // How do we know which payload failed and how to debug it later?
    res.sendStatus(500);
  }
});

With Hooque

Simple REST consumer with Ack/Nack retries

// Stream form submissions from Hooque over SSE
const HOOQUE_URL = process.env.HOOQUE_URL; // e.g. https://app.hooque.io/queues/cons_form_submissions
const TOKEN = process.env.HOOQUE_TOKEN;
const headers = { Authorization: `Bearer ${TOKEN}` };

// Signature verification is handled by Hooque before messages enter this stream.
const streamResp = await fetch(HOOQUE_URL + "/stream", { headers });

for await (const line of readSseLines(streamResp.body)) {
  if (!line.startsWith("data:")) continue;

  const event = JSON.parse(line.slice(5)); // { payload, meta }
  const payload = event.payload;
  const meta = event.meta;

  try {
    await process_form_payload(payload); // form_response
    await fetch(meta.ackUrl, { method: "POST", headers });
  } catch (err) {
    // Failed message can be inspected in Hooque, and we receive an alert about it.
    await fetch(meta.nackUrl, {
      method: "POST",
      headers: { ...headers, "Content-Type": "application/json" },
      body: JSON.stringify({ reason: String(err) }),
    });
  }
}

Key Benefits

A lead pipeline that does not drop submissions under pressure.

Zero lost submissions

Persist every payload instantly so leads never vanish on downtime.

Simple REST consumption

Pull messages with `GET /queues/{id}/next` and Ack/Nack using action URLs.

No infrastructure overhead

No queue cluster, no retry logic, no cron glue — just a hosted endpoint and a queue.

How It Works

Turn form submissions into a durable queue your backend can process safely.

1

Create a webhook

Create a Hooque webhook for form submissions and copy the endpoint URL.

2

Point provider to Hooque

Configure Typeform/Jotform to send submissions to your hosted endpoint.

3

Consume from the queue

Pull submissions and Ack/Nack depending on downstream success.

FAQ

Form webhook processing FAQ

Common questions about reliability, duplicates, and signature verification for submissions.

No. Submissions are accepted and queued first, then processed asynchronously when your downstream systems are available again.
No. Form providers send to a hosted Hooque endpoint. Your worker consumes from the queue using outbound requests (REST or SSE).
Yes for many providers (for example, Typeform). If a provider is not supported, you can still secure ingest with tokens or generic HMAC/API-key strategies.
Assume retries and duplicates. Use a stable idempotency key (submission id when available) and only ack once the lead has been safely stored.
Yes. JSON is returned as JSON, and non-JSON payloads are preserved with their content type so you can process attachments or custom formats safely.
Yes. Use REST pull for batch/cron workers, or SSE streaming for real-time lead workflows.

Still have questions?

Contact our support team

Start Processing Typeform & Jotform Webhooks in 2 Minutes

Capture every submission instantly and process leads in the background-no credit card required.

Start for free

No credit card required