# Ways to integrate: API, SDKs, and no-code links

Source: https://help.didit.me/integration/integration-options
Updated: 2026-10-12

You don't need to write code to start verifying people with Didit - use a no-code link, or bring in an SDK or the API when you want automation.

Three routes. **No-code links** need no backend at all. **The API plus a redirect**
is the standard integration. **SDKs** put the flow inside your own app - and are
the only route that supports NFC. **Developers → Quick start** in the console walks
you through each. Whichever you pick, get results back with
[webhooks](https://help.didit.me/integration/webhooks-basics).

[Video: The complete integration guide - Didit Academy](https://www.youtube.com/watch?v=fX03-WEu_EI)

[Video: KYC integration options: redirect link vs iFrame vs native SDK - Didit Academy](https://www.youtube.com/watch?v=MxMFf43KONg)

You don't need a developer to launch identity verification with Didit. There's a no-code option that takes minutes, plus API and SDK options for when you want it automated inside your own product.

## Can I use Didit without coding?

Yes. Once you've [built a workflow](https://help.didit.me/workflows/build-a-verification-workflow) in the console, you can generate a verification session two ways with zero code:

![The Integrate Didit page in the Didit console, with its setup checklist and the ways to integrate](https://help.didit.me/screenshots/integrate-light.webp)

*Integrate Didit (Developers → Quick start) is the shortest path from nothing to a working session.*

1. **Verification link (one-time)**

   Press **New verification** (on Home, the verifications list, or a person's
   profile), pick a **workflow**, add your own ID for the person under **Vendor
   data**, and press **Create verification**. Then send the link by email, copy it,
   or show the QR code. The **Single check** tab runs one check, such as AML
   screening, without a whole workflow.

2. **Reusable link (Unilink)**

   Each workflow also has one reusable link that starts a fresh session on every visit. Put it behind a button on your site, print it as a QR code for a kiosk or branch, or share it with affiliates. See [reusable links](https://help.didit.me/integration/reusable-links).

Both skip the API and your backend entirely - the right choice for MVPs, manual review, in-person verification, or getting started before you've built anything custom.

## When you want automation

[Video: Connect Didit to Claude with MCP - Didit Academy](https://www.youtube.com/watch?v=I3UkFIhW548&t=71)

If you need the result to update your own systems automatically - not just show up in the console - you'll want the API or an SDK:

| You want to... | Use |
|---|---|
| Redirect users to a hosted verification page from your app | A single API call to create a session, then redirect to the returned URL |
| Embed verification inside your web app | The [JavaScript SDK](https://docs.didit.me/integration/web-sdks/javascript-sdk) or the [in-context iframe](https://docs.didit.me/integration/web-sdks/incontext-iframe) |
| Verify inside a native iOS, Android, Flutter, or React Native app | The matching [native SDK](https://help.didit.me/integration/mobile-sdks) - required for NFC |
| Add verification to WordPress/WooCommerce or Shopify | The [WordPress/WooCommerce](https://docs.didit.me/integration/web-sdks/wordpress-woocommerce) or [Shopify](https://docs.didit.me/integration/web-sdks/shopify) plugin - no code required |
| Wire it into an automation tool | The API from [Zapier](https://docs.didit.me/integration/engines/zapier), n8n, or any tool that can make an HTTP request and receive a webhook |
| Get results pushed to your backend the moment they're ready | [Webhooks](https://help.didit.me/integration/webhooks-basics) |
| Run individual checks yourself (batch processing, custom capture UI) | The standalone APIs, called directly instead of through a workflow session |

## Sending the link yourself

If you create a session through the API, Didit returns the verification URL - and delivering it is then yours to do. Sending it from your own product, with your own copy and branding, is usually the better experience anyway: the person already trusts you, and a message from an unfamiliar sender is a conversion cost.

If you need Didit to email the person instead, pass contact details when creating the session. Confirm what's supported for your setup rather than assuming, and note that the **email language is a separate field** from the flow language. See [setting the verification language](https://help.didit.me/workflows/verification-languages).

## Choosing between hosted, embedded, and native

| | Hosted redirect | Embedded (web SDK / iframe) | Native SDK |
|---|---|---|---|
| Code required | Minimal | Moderate | Most |
| User leaves your app | Yes | No | No |
| NFC chip reading | No | No | **Yes** |
| Best camera behaviour | Good | Good | Best |
| Custom domain removes Didit from the URL | Yes | n/a | n/a |

If NFC matters to you, that row decides it: the chip can't be read from a browser page. See [NFC chip verification](https://help.didit.me/documents-coverage/nfc-chip-verification).

Which embedded options are available on your plan is worth confirming with your Didit contact before you scope a project around one.

## Standalone APIs vs workflow sessions

A workflow session runs the checks together, produces one aggregate decision, and is billed per completed feature. A standalone API call runs one check on data you supply, returns just that result, and is **billed per call** at its own list price.

Standalone calls are the right tool for batch processing, for a capture UI you built yourself, or for a check you want to run outside an onboarding flow. They're the wrong tool if you wanted one aggregate decision for the whole flow.

## Testing before you go live

Switch the console to **Sandbox** with the pill under your application's name,
create a sandbox API key there, and use it. Every check is mocked, nothing is
billed, and you can force any outcome you want. Sandbox keeps its own data,
keys, webhooks and lists, apart from Live.

[testing in sandbox](https://help.didit.me/getting-started/sandbox-and-testing)

## Next steps

- Set up a workflow first if you haven't: [building a verification workflow](https://help.didit.me/workflows/build-a-verification-workflow)
- Get results the moment they're ready: [getting verification results with webhooks](https://help.didit.me/integration/webhooks-basics)
- Where to find your API key: [managing your API keys](https://help.didit.me/account-organization/api-keys)
- When something returns an error: [API errors and what they mean](https://help.didit.me/integration/api-errors)

## Connecting AI tools

On **Connect AI tools**, select your tools and follow their setup instructions. When authorizing a connection, choose the intended organization and review the requested permissions before approving. If the account or organization is wrong, switch it before granting access.