Survey integrations

Add VerifyHuman to the survey platform you already use. Pick your platform from the table below and follow its one-page recipe. The recommended setup is the same everywhere: you create a link in the VerifyHuman dashboard and paste it into your survey as the starting point. That's the whole job.

Do I need a developer?

No — not for the recommended setup on any platform. The no-code hosted link path works on every platform in this guide. You make a link in the dashboard, paste it in as your survey's entry point, and you're done. No code, no developer.

The optional inline snippet puts the check inside a survey question instead of on a separate page. It is a small copy-paste block of JavaScript, it is offered on only five platforms (Qualtrics, Forsta, Alchemer, LimeSurvey, Sawtooth), and it is never required — the hosted link does the same job. Anything below labelled “Option B”, “optional”, or “for developers” is polish you can skip.

Which path should I use?

There's one technical fact that decides everything:

The live webcam check needs to run on a normal, full web page. Browsers block or limit the camera inside the small embedded frames that some survey tools use to display a survey. So the camera works reliably in exactly two places: (1) on a page that is the survey platform's own site and allows custom code, or (2) on a VerifyHuman-hosted page that we control.

That gives two strategies:

• Redirect (verify-first) — works everywhere. Send respondents to a VerifyHuman-hosted verification page before the survey. They verify there (the camera works), and on pass we hand them into your survey carrying a signed verdict. This is the universal path and the easiest to set up. It is the only option on SurveyMonkey, Typeform, Jotform, Cint, and Dynata.
• Inline embed — premium, no extra hop. Drop a small snippet into the survey so the check appears inside a question page. This is only possible on platforms where the survey runs first-party and allows custom JavaScript: Qualtrics, Forsta, Alchemer, LimeSurvey, Sawtooth.

When in doubt, use Redirect (verify-first). It keeps fraud out before it consumes your quota, needs no code, and is the same to explain to anyone: “paste this link as your survey's entry point.”

Platform index

Two ways to add VerifyHuman

A. No-code hosted link (works on every platform)

1. In the VerifyHuman dashboard, open your Project → “Survey integrations” tab and click Create link.
2. Choose the platform and the integration type:
   • Redirect — verify first (recommended): verify, then enter the survey.
   • Redirect — verify after: finish the survey, then verify (use this when verification should gate reward payout rather than entry).
   • Inline embed: only offered for the five custom-JS platforms (see B below).
3. Set the Pass redirect URL (where verified respondents go — usually your survey link) and the Fail redirect URL (where rejected respondents go — a screenout / disqualification page).
4. (Panel studies only) pick a Cint or Dynata preset and fill in the respondent-id parameter and the screenout / quota-full / security-terminate URLs. See Cint / Dynata below.
5. (Optional) list any passthrough params — inbound query-string values you want threaded through to the redirect and the webhook (e.g. a panel RID).
6. Save. You get a shareable link:

   https://vhuman.riwi.com/v/<linkId>

   The respondent verifies on that VerifyHuman-hosted page, then is auto-redirected to your pass or fail URL carrying a signed vh_token. You paste this v/<linkId> URL into your platform at the spot named in that platform's section below (survey entry point, redirect field, or panel router entry link).

The verdict comes back two ways: as the signed vh_token appended to your pass URL (verify it per the signed-redirect guide), and via the verification.completed / verification.scored webhook.

B. Inline snippet (Qualtrics, Forsta, Alchemer, LimeSurvey, Sawtooth only)

The check appears inside a survey question. Each of those five sections below gives you a copy-paste snippet. All of them:

1. Load the SDK from the CDN:

   <script src="https://vhuman.riwi.com/sdk/v1/verifyhuman.umd.js"></script>

2. Mount it, using your project id as the siteKey (find it in the dashboard under Project → Settings → Keys):

   VH.mount(element, {
     siteKey: "<projectId>",
     onResult: function (r) { /* gate the Next button, store the verdict */ },
   });

3. Gate the platform's Next / Submit button until the result is pass (or scored), and write the verdict into a response field.

One required step for inline embeds: add the survey vendor's domain to your project's Allowed Domains (dashboard → Project → Settings), or the mount will be refused. Each section names the exact domain.

Qualtrics

Recommended path: Inline embed (Qualtrics runs first-party and supports custom JavaScript). Redirect (verify-first) also works and needs no code.

Prerequisites for the inline path: your Qualtrics license must have Allow JavaScript enabled (a paid-license feature; ask your brand admin).

There is no iframe variant. The hosted /v/<linkId> page is a top-level navigation target and is served with X-Frame-Options: DENY — framing it will be blocked by the browser. Use the redirect path (Option A) or the inline SDK (Option B); a cross-origin iframe would also need the parent to grant allow="camera", which most survey platforms do not.

Option A — Hosted link (no code)

1. In the dashboard: Project → Survey integrations → Create link. Platform = Qualtrics, integration type = Redirect — verify first.
2. Set Pass redirect URL to your Qualtrics survey's anonymous link, and Fail redirect URL to a disqualification page. Save → copy https://vhuman.riwi.com/v/<linkId>.
3. Distribute that v/<linkId> link as your study's entry point (in place of the raw Qualtrics link). Respondents verify first, then land in the survey.
4. Read the verdict back in Qualtrics: the redirect arrives with ?vh_verdict=pass (and ?vh_token=...). In Survey Flow add an Embedded Data element with a blank field named vh_verdict before your first block — Qualtrics captures the matching query param automatically.

Option B — Inline embed

Injection points:

1. Load the SDK once: Look & Feel → General → Header → Source (<>) and paste the <script> tag.
2. Declare the field: in Survey Flow, add an Embedded Data element with a blank field vh_verdict.
3. Mount + gate: on your verification question, open Question behavior → JavaScript and paste the snippet.

Header (loads the SDK):

<script src="https://vhuman.riwi.com/sdk/v1/verifyhuman.umd.js"></script>

Question JavaScript (mounts, gates Next, stores verdict):

Qualtrics.SurveyEngine.addOnReady(function () {
  var self = this;
  self.disableNextButton();
  VH.mount(this.questionContainer, {
    siteKey: "<projectId>",                       // your project id
    respondentId: "${e://Field/ResponseID}",
    onResult: function (r) {
      if (r.status === "pass" || r.status === "scored") {
        // New Survey-Taking Experience: must use setJSEmbeddedData (NOT setEmbeddedData)
        Qualtrics.SurveyEngine.setJSEmbeddedData("vh_verdict", r.status);
        self.enableNextButton();
      }
    },
  });
});

Add Qualtrics's survey domain (e.g. *.qualtrics.com) under your project's Allowed Domains in the dashboard, or the mount is refused.

Gotchas

• New Survey-Taking Experience (the 2026 default): setEmbeddedData() silently fails — you must use setJSEmbeddedData(), and when you pipe or reference the value elsewhere it's named __js_vh_verdict, not vh_verdict. Declare the plain vh_verdict field in Survey Flow first.
• jQuery is no longer preloaded in the new experience. Our SDK is vanilla JS so it's fine — but don't paste jQuery-dependent helper code alongside it.
• Embedded collector caveat: capturing inbound ?vh_verdict= only works on the standard survey link, not when the survey is embedded elsewhere.
• For a server-side source of truth, add a Workflows → Web Service Task that calls VerifyHuman on completion, or rely on the webhook.

Forsta / Decipher

Recommended path: Inline embed — Forsta/Decipher is the most open platform for custom code (it even ships a native video element, so first-party camera is reliable). Redirect (verify-first) also works and needs no code.

Prerequisites: none for the client-side inline embed below. Only if you want Forsta's in-survey server call (v2SendRequest) to reach VerifyHuman, ask Forsta Support to add our domain to your request_allowed allowlist — but that's optional; the client SDK + button gate below needs no allowlist.

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = Forsta / Decipher, type = Redirect — verify first.
2. Pass redirect URL = your survey URL; Fail redirect URL = a terminate page. Save → copy https://vhuman.riwi.com/v/<linkId>.
3. Use the v/<linkId> link as the study entry point. On return, capture the verdict with a Survey Redirect / URL variable ([url ...] inbound) and store it into a Hidden Question.

Option B — Inline embed

Injection points:

1. Load the SDK: upload verifyhuman.umd.js to the survey's static directory and reference it via ss:customJS, or inject it at runtime from an <html> element using the CDN tag below.
2. Mount + gate: add an <html> element with a mount target (<div id="vh">) and the script. Hide Forsta's continue button (#btn_continue) until pass.

<div id="vh"></div>
<script src="https://vhuman.riwi.com/sdk/v1/verifyhuman.umd.js"></script>
<script>
  document.querySelector("#btn_continue").style.display = "none";
  VH.mount("#vh", {
    siteKey: "<projectId>",
    onResult: function (r) {
      if (r.status === "pass" || r.status === "scored") {
        // store the verdict in a hidden question field, then reveal Next
        var input = document.querySelector('input[name="vh_verdict"]');
        if (input) input.value = r.status;
        document.querySelector("#btn_continue").style.display = "";
      }
    },
  });
</script>

Store the verdict: create a Hidden Question (e.g. vh_verdict) and let the snippet write into its .val input (shown above), or set it server-side via an <exec> Python block. Pipe it onward with [pipe: vh_verdict].

Add your Forsta survey domain to the project's Allowed Domains in the dashboard before going live.

Gotchas

• #btn_continue is Forsta's continue button id — hide it on load, reveal it only on pass. Double-check the id on your theme if you've customized it.
• v2SendRequest needs the request_allowed allowlist (a Forsta Support ticket). For a no-touch setup, skip it — the client SDK + button gate + hidden-question write is enough; use our webhook for the server-side source of truth.
• The REST responses/data endpoint is read+write if you prefer to backfill the verdict server-side.

Alchemer

Recommended path: Inline embed (Alchemer surveys run first-party, so the camera works without iframe plumbing). Redirect (verify-first) also works and needs no code.

Prerequisites for the inline path: the account's Integrations permission must be enabled (ask your Alchemer admin). Note that custom JavaScript is “outside normal support” scope on Alchemer — that's expected; the snippet below is self-contained.

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = Alchemer, type = Redirect — verify first.
2. Pass redirect URL = your survey link; Fail redirect URL = a disqualification page. Save → copy https://vhuman.riwi.com/v/<linkId>.
3. Use the v/<linkId> link as the study entry point. On the way back into later pages, a URL Redirect action with “Fields To Pass” carries the verdict, and a Hidden Value action stores it.

Option B — Inline embed

Injection point: add a JavaScript Action to the verification page (Alchemer supplies the <script> tags; control when it runs via the Action's Logic tab).

<div id="vh"></div>
<script src="https://vhuman.riwi.com/sdk/v1/verifyhuman.umd.js"></script>
<script>
  // Hide Alchemer's Next button until verified
  var next = document.querySelector("#sg_NextButton");
  if (next) next.style.display = "none";
  VH.mount("#vh", {
    siteKey: "<projectId>",
    onResult: function (r) {
      if (r.status === "pass" || r.status === "scored") {
        // write into a Hidden Value field, then reveal Next
        var hv = document.querySelector('input[name="vh_verdict"]');
        if (hv) hv.value = r.status;
        if (next) next.style.display = "";
      }
    },
  });
</script>

Store the verdict: add a Hidden Value action named vh_verdict on the same page; the snippet writes the result into it.

Add your Alchemer survey domain to the project's Allowed Domains in the dashboard before going live.

Gotchas

• #sg_NextButton is Alchemer's Next-button id — hide it on load, reveal it only on pass.
• jQuery is not guaranteed to be present — our SDK is vanilla JS, so don't rely on $ in the surrounding code.
• For a server-side source of truth, add a Webhook action (it fires on page submit, must return HTTP 200, and Alchemer retries up to 10×), or use our own verification.completed webhook.

LimeSurvey

Recommended path: Inline embed — LimeSurvey is open-source and self-hostable, so you get full control and the camera works on a first-party HTTPS page. Redirect (verify-first) also works and needs no code.

Prerequisites for the inline path: Global Settings → Security → Filter HTML for XSS = No (a single global toggle; trivial on a self-hosted instance, required so your custom <script> isn't stripped).

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = LimeSurvey, type = Redirect — verify first.
2. Pass redirect URL = your survey URL; Fail redirect URL = a terminate page. Save → copy https://vhuman.riwi.com/v/<linkId>.
3. Use the v/<linkId> link as the study entry point. On return, prefill a hidden question via ?QCODE=value&newtest=Y; on the way out, the End URL can carry {SAVEDID} / {TOKEN} / {PASSTHRU:*}.

Option B — Inline embed

Injection point: add the SDK at the question, theme (config.xml), or plugin level. The simplest is a question with HTML/JS source.

<div id="vh"></div>
<script src="https://vhuman.riwi.com/sdk/v1/verifyhuman.umd.js"></script>
<script>
  // Hide LimeSurvey's Next/Submit button until verified
  var btn = document.querySelector("#movenextbtn, #movesubmitbtn");
  if (btn) btn.style.display = "none";
  VH.mount("#vh", {
    siteKey: "<projectId>",
    onResult: function (r) {
      if (r.status === "pass" || r.status === "scored") {
        // write into the hidden short-text answer (replace XXXX with the SGQA id)
        var ans = document.querySelector("#answerXXXX");
        if (ans) ans.value = r.status;
        if (btn) btn.style.display = "";
      }
    },
  });
</script>

Store the verdict: a hidden short-text question; the snippet writes the status into its #answerXXXX input (substitute your question's id).

More robust gate (recommended): instead of hiding the button, add a hidden + mandatory equation question whose ExpressionScript validation requires the stored verdict to equal pass — LimeSurvey then refuses to advance until the verdict is present, even if the button is force-clicked.

Add your LimeSurvey domain to the project's Allowed Domains in the dashboard before going live.

Gotchas

• XSS filter must be off (Global Settings → Security) or LimeSurvey strips your <script>. This is a global instance setting.
• #movenextbtn / #movesubmitbtn are the navigation button ids; the submit button only appears on the last page.
• For a server-side source of truth, use the afterSurveyComplete plugin event (outbound webhook) or the RemoteControl 2 JSON-RPC API — or our own verification.completed webhook.

Sawtooth (Lighthouse Studio / Discover)

Recommended path: Inline embed — Sawtooth's Free Format question gives you full HTML/CSS/JS and the cleanest hard gate of any platform (the page simply won't submit while an error message is set). Redirect (verify-first) also works and needs no code.

Prerequisites: none beyond using a Free Format question (or an inline <script>) on the verification page.

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = Sawtooth, type = Redirect — verify first.
2. Pass redirect URL = your study link; Fail redirect URL = a terminate page. Save → copy https://vhuman.riwi.com/v/<linkId>.
3. Use the v/<linkId> link as the study entry point. Inbound respondent IDs are captured with Pass-In Fields; the Terminate question links out (also your panel-router hook if the study is Cint/Dynata-fed).

Option B — Inline embed

Injection point: a Free Format question. Load the SDK from our CDN (or via <script src="[%GraphicsPath()%]verifyhuman.umd.js"> if you host it locally), mount it, and use Custom JavaScript Verification to gate the page.

<div id="vh"></div>
<input type="hidden" name="FF1_token" id="FF1_token" />
<script src="https://vhuman.riwi.com/sdk/v1/verifyhuman.umd.js"></script>
<script>
  window.__vhPassed = false;
  VH.mount("#vh", {
    siteKey: "<projectId>",
    onResult: function (r) {
      if (r.status === "pass" || r.status === "scored") {
        window.__vhPassed = true;
        document.getElementById("FF1_token").value = r.status; // store in Free Format var
      }
    },
  });
</script>

Gate the page — in the question's Custom JavaScript Verification box:

if (!window.__vhPassed) strErrorMessage = "Please complete verification.";

While strErrorMessage is a non-empty string, Sawtooth refuses to submit the page — the gate is enforced server-side by the survey engine, not just hidden in the DOM.

Store the verdict: a Free Format hidden variable (e.g. FF1_token), written by the snippet above.

Add your Sawtooth survey domain to the project's Allowed Domains in the dashboard before going live.

Gotchas

• strErrorMessage is the gate — set it to a non-empty string to block submission, clear it (leave __vhPassed = true) to allow it. This is more robust than hiding a Next button.
• Sawtooth has no first-class submission webhook, so for a server-side source of truth lean on the redirect verdict (the signed vh_token) or our own verification.completed webhook rather than a Sawtooth-fired one.

SurveyMonkey

Recommended path: Redirect (verify-first). SurveyMonkey allows no custom JavaScript on any tier (Custom CSS is Enterprise-only and can't load scripts), so an inline embed is not possible — you must verify on a VerifyHuman-hosted page first, then hand respondents into the survey.

Prerequisite: use a Web Link collector for the survey. The End-Page redirect (needed to send fails to a disqualification URL) is not available on the Website (embed) collector.

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = SurveyMonkey, type = Redirect — verify first.
2. Pass redirect URL = your survey's Web Link collector URL. Fail redirect URL = a disqualification page. Save → copy https://vhuman.riwi.com/v/<linkId>.
3. Distribute the v/<linkId> link as your study entry point instead of the raw SurveyMonkey link.
4. Read the verdict back: the redirect into your Web Link collector carries ?vh_verdict=pass as a Custom Variable — SurveyMonkey stores it in the results alongside the responses (like a hidden question). On fail, the link instead sends the respondent to your disqualification URL.

Option B — Inline embed

Not possible on SurveyMonkey. There is no custom-JavaScript slot on any plan (Enterprise Custom CSS cannot run logic or load scripts), and the camera can't run inside the embed collector's frame. Use Option A.

Optional — confirm the verdict on your server (for developers)

You can skip this. Option A already returns the verdict. This section is only for teams that want their own server-side check.

Subscribe a webhook to response_completed. The payload is just a notification — fetch the full response (and its custom variables, including vh_verdict) via the REST API v3, or simply rely on VerifyHuman's own verification.completed webhook, which carries the signed verdict directly.

Gotchas

• Web Link collector only. End-Page redirects don't fire on the Website / embed collector — fails wouldn't be routed.
• Custom Variables are the only place the verdict can land in SurveyMonkey results; confirm your plan exposes the Custom Variables UI before launch.
• The signed vh_token (also appended on the pass redirect) is the tamper-proof proof — the in-survey vh_verdict custom variable is convenience only.

Typeform

Recommended path: Redirect (verify-first). The Typeform form runs inside a locked, cross-origin iframe and accepts no custom code (explicitly off-roadmap), so an inline embed is not possible — the camera can't run in that frame. Verify on a VerifyHuman-hosted page first, then hand respondents in.

Prerequisite: the verify-after variant (redirect on completion) requires the Plus plan or above. The verify-first variant works on any plan.

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = Typeform, type = Redirect — verify first.
2. Pass redirect URL = your Typeform link with the verdict mapped to a Hidden Field, e.g. https://yourname.typeform.com/to/AbC123#vh_verdict=pass. Fail redirect URL = a disqualification page. Save → copy https://vhuman.riwi.com/v/<linkId>.
3. In Typeform, add a Hidden Field named vh_verdict (Create → Hidden Fields). Hidden-field values are fixed before the form starts, which is exactly right for an incoming verdict.
4. Distribute the v/<linkId> link as your study entry point.

(Verify-after alternative, Plus+): set the integration type to Redirect — verify after and use Typeform's redirect-on-completion with Recall params to send finished respondents to the v/<linkId> page.

Option B — Inline embed

Not possible on Typeform. The form is a sandboxed iframe with no custom-code slot, so the SDK can't be mounted inside it and the camera won't run there. Use Option A.

Optional — confirm the verdict on your server (for developers)

You can skip this. Option A already returns the verdict. This section is only for teams that want their own server-side check.

Subscribe the Webhooks API: on submit, Typeform posts a rich form_response payload (form token, variables, hidden fields including vh_verdict, and answers). The Responses API mirrors the same data. Or rely on VerifyHuman's own verification.completed webhook with the signed verdict.

Gotchas

• Hidden Fields vs. Variables: Hidden Fields are set before the form starts (use these for the incoming verdict). Variables are for values computed during the form — not what you want here.
• Redirect-on-completion is Plus+. Verify-first needs no special tier; only the verify-after flow does.
• The signed vh_token on the pass redirect is the tamper-proof proof; the vh_verdict hidden field is convenience only.

Jotform

Recommended path: Redirect (verify-first). Jotform strips <script> from hosted forms (you only get the Paragraph-widget HTML and per-widget Custom CSS), and its widget iframes are sandboxed with no camera grant — so an inline embed that hosts the webcam is not possible. Verify on a VerifyHuman-hosted page first, then hand respondents in.

Prerequisite: none for the verify-first flow.

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = Jotform, type = Redirect — verify first.
2. Pass redirect URL = your Jotform link (optionally with prefill parameters that populate hidden fields, e.g. ?vh_verdict=pass). Fail redirect URL = a disqualification page. Save → copy https://vhuman.riwi.com/v/<linkId>.
3. In Jotform, add a hidden/short-text field vh_verdict; the URL prefill parameter populates it on entry.
4. Distribute the v/<linkId> link as your study entry point.

(Verify-after alternative:) set type = Redirect — verify after and use Settings → Thank-You Page → Redirect to an external link (with field placeholders) to send finished respondents to the v/<linkId> page. A Redirect with HTTP POST can also ship the whole submission to an endpoint.

Option B — Inline embed

Not possible on Jotform. Hosted forms strip custom <script> tags, and widget iframes are sandboxed without a camera grant — a framed “VerifyHuman” widget could only launch (pop out / redirect) to the real check, not host it. Use Option A.

Optional — confirm the verdict on your server (for developers)

You can skip this. Option A already returns the verdict. This section is only for teams that want their own server-side check.

Jotform supports native outbound webhooks and a REST API; subscribe a webhook to read the submission (with the vh_verdict field). Or rely on VerifyHuman's own verification.completed webhook with the signed verdict.

Gotchas

• <script> is stripped on hosted forms — there is no real inline-JS slot, so don't attempt to mount the SDK in a Paragraph widget.
• Widget iframes have no camera permission — even a published Jotform widget would have to redirect/pop out for the webcam step.
• The signed vh_token on the pass redirect is the tamper-proof proof; the prefilled vh_verdict field is convenience only.

Cint (incl. Lucid heritage)

Recommended path: Panel router (verify-first screener). Cint is a panel/sample router with no custom JavaScript — but its entry-link → exit-redirect model maps onto VerifyHuman's redirect mode almost exactly. Insert the VerifyHuman-hosted page as a pre-survey screener at study start: passes continue to the real survey; fails route straight to Cint's terminate URL with the right disposition.

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = Cint, type = Redirect — verify first.
2. Pick the Cint panel preset and fill it in:
   • Respondent-id param: rid (Cint substitutes the live value via [%RID%] on the entry link).
   • Pass / continue URL: your real survey's entry URL.
   • Screenout URL, Quota-full URL, Security-terminate URL: the Cint exit links for each disposition (below). The dashboard echoes rid onto each automatically.
3. Add rid to passthrough params so the respondent id threads through to the redirect and the webhook.
4. Save → copy https://vhuman.riwi.com/v/<linkId>. Set this v/<linkId> link as the study entry link in Cint (with ?rid=[%RID%] appended).

Option B — Inline embed

Not possible. Cint is a router with no JavaScript surface. Use Option A.

Disposition → outcome mapping

VerifyHuman routes each outcome to the matching Cint disposition code:

For a VerifyHuman fail, terminate with the fraud marker markers="CINT_Exchange_Security" so the rejection is flagged as a security termination, not an ordinary screenout.

Entry / exit URL shapes

Entry link (set in Cint, points at the VH-hosted page):

https://vhuman.riwi.com/v/<linkId>?rid=[%RID%]

[%RID%] is Cint's respondent-id substitution. The full entry URL must be ≤ 1999 characters; an optional SHA-1 signature, if used, must be the last parameter.

Exit / return (VH redirects back to Cint on the outcome):

https://<cint-host>/ClientCallBack.aspx?RID=<rid>&...   (+ S2S Respondent Outcomes API)

Gotchas

• Wait for the S2S 'success' response before redirecting. Cint's server-to-server Respondent Outcomes call must confirm before the browser redirect fires, or the disposition can be lost.
• Some Cint protection terminations (131 / 301 / 302 / 303) don't redirect — handle them as terminal, not as a continue.
• The security marker (CINT_Exchange_Security) is what distinguishes a fraud-terminate from a normal screenout — set it on VerifyHuman fails.

Dynata

Recommended path: Panel router (verify-first screener). Dynata is a panel/sample router with no custom JavaScript — but its entry-link → exit-redirect model maps onto VerifyHuman's redirect mode. Insert the VerifyHuman-hosted page as a pre-survey screener at study start: passes continue to the real survey; fails route to Dynata's screenout/terminate URL, echoing the respondent id.

Dynata has two entry styles — legacy Samplify (psid passthrough) and REX (signed entry link). Both are supported.

Option A — Hosted link (no code)

1. Dashboard: Project → Survey integrations → Create link. Platform = Dynata, type = Redirect — verify first.
2. Pick the Dynata panel preset and fill it in:
   • Respondent-id param: psid (Samplify) — VerifyHuman echoes it on every exit URL. For REX, the entry link is signed (see below).
   • Pass / continue URL: your real survey's entry URL.
   • Complete URL, Screenout URL, Overquota URL: the three Dynata exit links; the dashboard echoes psid onto each.
3. Add psid to passthrough params so the respondent id threads through to the redirect and the webhook.
4. Save → copy https://vhuman.riwi.com/v/<linkId>. Set this v/<linkId> link as the study entry link in Dynata.

Option B — Inline embed

Not possible. Dynata is a router with no JavaScript surface. Use Option A.

Disposition → outcome mapping

On a VerifyHuman fail, redirect to the Screenout/Terminate exit URL and echo the respondent id so Dynata reconciles the disposition.

Entry / exit URL shapes

Legacy Samplify — psid passthrough:

Entry:  https://vhuman.riwi.com/v/<linkId>?psid=<dynata-psid>
Exit:   https://<dynata-host>/complete?psid=<psid>     (Complete)
        https://<dynata-host>/screenout?psid=<psid>    (Screenout)
        https://<dynata-host>/overquota?psid=<psid>    (Overquota)

REX — signed entry link + signed outbound redirect:

Entry:  ...?respondent_id=<id>&expiration=<ts>&access_key=<key>&signature=<sig>
Exit:   ...?disposition=<code>&status=<status>&signature=<sig>

Gotchas

• Echo psid on every exit URL (Samplify) — Dynata reconciles the respondent by it; a missing psid drops the disposition.
• REX entry links are signed (respondent_id, expiration, access_key, signature) and the outbound redirect must carry disposition + status + signature — use the REX preset, not the Samplify one, for REX studies.
• The signed vh_token on the pass redirect is VerifyHuman's tamper-proof proof, independent of Dynata's own disposition reconciliation.

Next steps

• Building your own embed? See the SDK guide for the full VH.mount surface and result shape.
• Verifying the signed vh_token server-side? See the Server API reference and the webhook contract.
• Already a customer? Your project's Survey integrations tab pre-fills these recipes with your real site key and link ids — sign in to the dashboard.