Send VideoAsk Responses to Klaviyo

TL;DR: Two facts about this pipeline are not true of any other one documented here. VideoAsk does not sign its webhooks — it sends a shared token in a header you name yourself, and Slashbin compares it directly. And a Klaviyo destination receives your transformed payload verbatim — no slashbin_job_id wrapper, no metadata, no nesting. Your Golden Model's output is the body Klaviyo receives. Get either wrong and the integration fails in a way that looks like something else.

The Problem

You want a video response — a lead who recorded an answer on your VideoAsk form — to land in Klaviyo as an event, so a flow can pick it up. Both ends of that pipeline break a rule the rest of our recipes taught you.

• You went looking for VideoAsk's signing algorithm. There isn't one. Every other source documented here — Stripe, Square, GitHub, Typeform, QuickBooks — computes an HMAC digest over the request body. VideoAsk sends a static shared token in a header. There is no digest, no encoding, and no signing payload to get wrong.
• You assumed the header name was VideoAsk's to choose. It is yours. You define both the header name and its value when you configure the webhook, which means the name has to match on both sides or nothing verifies.
• Your transform produced a body Klaviyo rejects. Every other destination type receives a Slashbin envelope with your payload nested inside it. Klaviyo does not. A model written against the wrapped shape sends Klaviyo an object it has no schema for, and the 400 that comes back looks like a mapping bug rather than a shape mismatch.
• Your routing rules stopped matching after someone edited the form. VideoAsk sends no event-type field. The topic is the form's title — a human-editable label — so a rename in the VideoAsk editor changes the value your rules match on.

None of these are Klaviyo bugs or VideoAsk bugs. They are properties of how the two ends are configured, and each one is invisible until it costs you an afternoon.

The Solution

Route VideoAsk through a Slashbin project with a Klaviyo destination. The token comparison, the topic path, and the Klaviyo request contract all become stored configuration:

• The raw payload exactly as VideoAsk sent it — bytes and headers.
• Header-token verification at the gateway, in constant time, before your Golden Model or Klaviyo sees anything.
• The resolved topic — what Slashbin read out of $.form.title for that specific response.
• The transform result — the Klaviyo Events object your model produced, or the error it threw.
• Every delivery attempt to Klaviyo — response code, response body, and timing — plus replay from Slashbin's own storage.

Outcome: VideoAsk only has to reach Slashbin once. Klaviyo's 400s become readable response bodies in a delivery log instead of a silence you have to reproduce.

Step 1: Create a VideoAsk Project in Slashbin

1. Click Create New Project and select VideoAsk.
2. Type: Choose Transactional — a form response is a discrete business event, not a metric.

Selecting VideoAsk loads its verification contract into the project — and it is a different shape from every other one in these recipes:

Slashbin's gateway has no VideoAsk-specific code path. VideoAsk works because that contract is stored and applied on every request — the same mechanism that verifies the HMAC sources, taking a different branch.

Step 2: Set the Header Name and Secret

The header name is yours to choose — VideoAsk does not fix one and Slashbin does not prefill one. Set both values in Slashbin first, then copy them outward into VideoAsk.

1. In Slashbin, type a Header Name. The field is empty and required — the wizard will not advance without it. x-videoask-signature is a fine choice if you have no preference; any name works as long as VideoAsk sends the same one.
2. Selecting VideoAsk already generated a secret and put it in the Secret Value field — VideoAsk's Header Token. Copy it now: it is shown once, and you will not be able to view it again. Click Generate New for a different one, or paste your own strong random string over it.
3. In VideoAsk, open the form's webhook settings and add the Slashbin Ingestion URL as the endpoint.
4. In VideoAsk, add a custom header using the same name you typed in Slashbin, and paste the copied secret as its value.
5. Submit a test response, then open the Slashbin Delivery Log. A verified delivery is proof that the name and the value match on both sides.

Rotating the token later means updating it in both places. Until both sides match, verification fails closed, and every rejection is visible in the Delivery Log rather than lost.

Step 3: Transform the Response Into a Klaviyo Event

What VideoAsk sends

A VideoAsk form response arrives shaped roughly like this:

{
  "event_type": "form_response",
  "event_id": "01J6WQ4C7K2M9N3P5R7T9V1X3Z",
  "interaction_id": "a8f21c04-6b3e-4f1d-9c72-0d5e6a1b8c34",
  "form": {
    "form_id": "f0f4a7c2",
    "title": "Demo Request"
  },
  "contact": {
    "contact_id": "c7d1e9b3",
    "name": "Lauren Ramirez",
    "email": "[email protected]",
    "phone_number": "+15125550123",
    "answers": [
      {
        "question_id": "q1",
        "question_label": "What are you trying to solve?",
        "type": "video",
        "media_url": "https://media.videoask.com/...",
        "transcript": "We are drowning in webhook plumbing."
      }
    ]
  }
}

Field names vary with how the form is built, so read the stored raw body of your first real delivery rather than mapping against this example. That is what the raw payload is stored for.

The topic is the form's title

VideoAsk does not send an event-type field you can route on the way Stripe or Typeform do. Slashbin reads the topic from $.form.title — the form's own name — because that is the field that identifies which form a response came from. It is an identifier of convenience, not a contract, and one consequence follows directly:

If one project takes responses from several forms, that is exactly what the topic is for: one rule per form title, each pointing at the destination that should own it.

Map it into a Klaviyo Events object

Define the mapping once in the Transformation IDE. The target shape is Klaviyo's Events API request body, and — per the callout above — it is the whole output, top level:

{
  "data": {
    "type": "event",
    "attributes": {
      "properties": {
        "form_title": "Demo Request",
        "interaction_id": "a8f21c04-6b3e-4f1d-9c72-0d5e6a1b8c34",
        "transcript": "We are drowning in webhook plumbing."
      },
      "metric": {
        "data": {
          "type": "metric",
          "attributes": { "name": "VideoAsk Response" }
        }
      },
      "profile": {
        "data": {
          "type": "profile",
          "attributes": { "email": "[email protected]" }
        }
      }
    }
  }
}

The fields that carry the VideoAsk response into it:

Toggle Required ON for the profile identifier and the form title. An event Klaviyo cannot attach to a profile is one it will reject, and better that it is held as invalid than sent to be refused.

Click Publish to activate the model. Unpublished models don't drop events: incoming responses are captured in the Dead Letter Queue until a matching model is live, so nothing is lost while you iterate.

Step 4: Add Klaviyo as the Destination

On the Outbound tab, click + Add Destination and choose Klaviyo. The request contract is fixed by the destination type:

Two conveniences worth knowing:

• The bare key is fine. Paste pk_... on its own and Slashbin adds the Klaviyo-API-Key prefix for you. Pasting the full Klaviyo-API-Key pk_... string works too — it is not double-prefixed.
• revision defaults to 2024-10-15. Leave it unset and Slashbin sends that value. Set it explicitly if you are pinning to a different Klaviyo API revision.

From there the guarantees are Slashbin's:

• Transient failure → retry with backoff. Klaviyo returning 429 or 502 for ninety seconds costs you nothing.
• Exhausted attempts → the Dead Letter Queue, holding the original raw VideoAsk payload, not a summary of it.
• Fixed the model → Replay. Slashbin re-delivers from its own storage, through the current model. Correct the profile mapping on Thursday and re-run Monday's responses through it — VideoAsk is not involved and does not need to be.
• Klaviyo rejected it? Read why. The attempt record carries Klaviyo's exact response body, which is where a shape error in your Events object shows up as a sentence rather than a status code.

Why Slashbin vs a Raw Handler

• The "where's the HMAC" question never comes up. Header name, token, constant-time comparison — stored as configuration and applied at the gateway. You do not write a second, different verification path just because this one source is not signed.
• The Klaviyo client you didn't write. URL, authorization scheme, and revision header come with the destination type. Your work is the payload shape, not the transport.
• Body-based routing without body-parsing code. $.form.title is a stored topic path, so telling three forms apart is three rules rather than an if-else chain over body.form.
• A rename is visible instead of silent. The resolved topic is recorded per delivery, so "why did this form stop routing" is one look at the Delivery Log.
• Delivery is retried and replayable. A video response is a person who recorded an answer and moved on. VideoAsk will not re-send it for you; Slashbin will.

Next Steps

• See the HMAC contract this source doesn't use — Send Typeform Submissions Anywhere covers the closest equivalent for form submissions.
• Compare another body-topic source with a nested path — Route LinkedIn Organization Webhooks.
• Go deeper on mapping and validation — read Golden Model.
• Send one response to more than one system — see Fan-Out Routing.
• Browse every supported source and destination on Integrations.