Aller au contenu
Aide

Toutes les pages de l’aide

Intégrer un formulaire avec le SDK JavaScript (React, Vue, Next.js, HTML)

Le SDK JavaScript Canard Form affiche un formulaire complet sur votre site en une ligne, avec React, Vue, Next.js, Nuxt ou une simple page HTML. Alternatives sans SDK : HTML et fetch.

Canard Form est un backend de formulaires hébergé : il valide et enregistre les réponses, envoie les notifications et applique la protection antispam. Pour afficher un formulaire sur votre site, la méthode recommandée est le SDK JavaScript @canardform/sdk. Aucune clé d'API, aucune route serveur et aucune variable d'environnement ne sont nécessaires.

L'onglet Intégrations → Intégration complète de chaque formulaire génère le code de cette page avec vos vrais champs. Les exemples ci-dessous utilisent VOTRE_FORMULAIRE à la place de l'identifiant du formulaire.

Le plus simple : copier-coller ce code

Collez ce code dans votre page, à l'endroit où le formulaire doit apparaître. C'est tout.

<div id="form"></div>
<script type="module">
    import { mountForm } from 'https://cdn.jsdelivr.net/npm/@canardform/sdk@1.0.0-alpha.4/+esm';
    mountForm('#form', 'VOTRE_FORMULAIRE');
</script>

Le formulaire complet s'affiche : champs, étapes, conditions, vérification anti-robot, erreurs et message de remerciement. Rien à installer, aucune clé, aucun serveur. Ce code fonctionne sur n'importe quelle page HTML, CMS ou template. Les sections suivantes montrent comment aller plus loin : composants dédiés, rendu serveur, design personnalisé.

Choisir une intégration

Votre projet Intégration recommandée
React, Next.js SDK : composant <CanardForm> ou hook useCanardForm
Vue, Nuxt SDK : composant <CanardForm> ou composable useCanardForm
Svelte, Angular, Astro, JavaScript avec un bundler SDK : mountForm()
Site statique, CMS, template sans outil de build SDK chargé depuis un CDN
Pas de JavaScript du tout Sans SDK : formulaire HTML classique

Pourquoi utiliser le SDK

Le SDK lit le formulaire publié et s'occupe de tout :

  • les champs, les libellés, les aides et les langues ;
  • les étapes, avec les boutons Précédent et Suivant ;
  • les conditions d'affichage ;
  • la vérification anti-robot (hCaptcha) ;
  • la validation dans le navigateur et les erreurs renvoyées par le serveur ;
  • le message de remerciement, le message « formulaire fermé » et le message de secours si Canard Form est injoignable ;
  • l'envoi sans doublon, même après une coupure réseau.

Une modification publiée dans Canard Form s'applique sur votre site sans changer votre code. Le SDK est open source et typé en TypeScript. Il fonctionne avec ou sans framework, et vous gardez la main sur le design : classes CSS, rendu d'un champ ou HTML complet.

Le SDK est en version alpha. Copiez la version indiquée dans l'onglet Intégrations, elle est tenue à jour.

Installer le SDK

Dans un projet qui utilise npm (avec Vite, webpack, React, Vue, Next.js, Nuxt, Svelte, Angular, Astro…) :

npm install @canardform/sdk@alpha

Ensuite, selon votre projet :

  • React, Next.js, Vue ou Nuxt : utilisez le composant <CanardForm> (voir React et Vue et Nuxt).
  • Tout autre projet (JavaScript sans framework, Svelte, Angular, Astro…) : appelez mountForm sur un élément de la page.
import { mountForm } from '@canardform/sdk';

// Construit le formulaire complet dans <div id="form"></div>
mountForm('#form', 'VOTRE_FORMULAIRE');

Charger le SDK depuis un CDN

Pour un site sans outil de build (site statique, CMS, template), chargez le SDK depuis jsDelivr :

<div id="form"></div>

<script type="module">
    import { mountForm } from 'https://cdn.jsdelivr.net/npm/@canardform/sdk@1.0.0-alpha.4/+esm';

    mountForm('#form', 'VOTRE_FORMULAIRE', {
        lang: 'fr',
        classes: { form: 'mon-formulaire', submit: 'mon-bouton' },
        onSubmitted: () => (window.location.href = '/merci'),
    });
</script>

Toutes les options sont facultatives et décrites dans Options de mountForm.

React

import { CanardForm } from '@canardform/sdk/react';

export default function ContactForm() {
    return <CanardForm formId="VOTRE_FORMULAIRE" />;
}

Pour garder votre design :

  • classes={{ form: '…', submit: '…' }} ajoute vos classes.
  • renderField remplace le rendu d'un champ par votre composant.
  • Le hook useCanardForm vous laisse écrire tout le HTML :
import { useCanardForm } from '@canardform/sdk/react';

export default function ContactForm() {
    const form = useCanardForm('VOTRE_FORMULAIRE');

    if (form.status === 'sent')
        return <p>Merci, votre message est bien envoyé.</p>;

    return (
        <form onSubmit={form.handleSubmit} onChange={form.handleChange}>
            <input type="text" name="nom" required />
            <input type="email" name="email" required />
            {form.isVisible('societe') && <input type="text" name="societe" />}
            <div ref={form.captchaRef} />
            <button type="submit" disabled={form.status === 'sending'}>
                Envoyer
            </button>
            {form.error && <p>{form.error}</p>}
        </form>
    );
}
  • form.isVisible(cle) applique les conditions d'affichage du formulaire.
  • form.captchaRef place la vérification anti-robot, si le formulaire l'exige.

Formulaire en plusieurs étapes : une section par étape, et des boutons pour avancer et reculer. L'onglet Intégrations génère ce code avec vos vraies étapes.

<section data-step="contact" hidden={!form.isStep('contact')}>
  {/* champs de l'étape « contact » */}
</section>
<section data-step="projet" hidden={!form.isStep('projet')}>
  {/* champs de l'étape « projet » */}
</section>

{form.step > 0 && (
  <button type="button" onClick={form.previous}>Précédent</button>
)}
{form.step < form.steps.length - 1 ? (
  <button type="button" onClick={(event) => form.next(event.currentTarget)}>Suivant</button>
) : (
  <button type="submit">Envoyer</button>
)}

Next.js (App Router)

Lisez le formulaire sur le serveur pour qu'il soit présent dès le HTML (SSR, meilleur pour le référencement et l'affichage), puis passez-le à un composant client :

// app/contact/page.tsx
import { getForm } from '@canardform/sdk';
import ContactForm from './ContactForm';

export default async function ContactPage() {
    const definition = await getForm('VOTRE_FORMULAIRE');

    return <ContactForm definition={definition} />;
}
// app/contact/ContactForm.tsx
'use client';
import type { PublicForm } from '@canardform/sdk';
import { CanardForm } from '@canardform/sdk/react';

export default function ContactForm({
    definition,
}: {
    definition: PublicForm;
}) {
    return <CanardForm formId="VOTRE_FORMULAIRE" definition={definition} />;
}

Vue et Nuxt

<script setup lang="ts">
import { CanardForm } from '@canardform/sdk/vue';
</script>

<template>
    <CanardForm form-id="VOTRE_FORMULAIRE" />
</template>

Pour remplacer un seul champ, utilisez le slot #field (voir Composant CanardForm).

Écrire tout le HTML avec le composable useCanardForm :

<script setup lang="ts">
import { useCanardForm } from '@canardform/sdk/vue';

const form = useCanardForm('VOTRE_FORMULAIRE');
</script>

<template>
    <p v-if="form.status.value === 'sent'">
        Merci, votre message est bien envoyé.
    </p>
    <form v-else @submit="form.handleSubmit" @input="form.handleChange">
        <input type="text" name="nom" required />
        <input type="email" name="email" required />
        <input v-if="form.isVisible('societe')" type="text" name="societe" />
        <div :ref="form.captchaRef" />
        <button type="submit">Envoyer</button>
        <p v-if="form.error.value">{{ form.error.value }}</p>
    </form>
</template>

Nuxt (SSR) : lisez le formulaire sur le serveur et passez-le au composant.

<script setup lang="ts">
import { getForm } from '@canardform/sdk';
import { CanardForm } from '@canardform/sdk/vue';

const { data } = await useAsyncData(() => getForm('VOTRE_FORMULAIRE'));
</script>

<template>
    <CanardForm form-id="VOTRE_FORMULAIRE" :definition="data" />
</template>

Svelte, Angular, Astro et autres

Avec un bundler, importez mountForm depuis @canardform/sdk et appelez-le sur un élément de la page, comme avec le CDN. Pour rendre le formulaire avec vos propres composants, createFormController (depuis @canardform/sdk/controller) fournit l'état, la validation, les étapes et l'envoi sans aucun rendu.

Options de mountForm

mountForm(cible, idFormulaire, options) construit le formulaire dans cible (un sélecteur CSS comme '#form', ou un élément HTML). Toutes les options sont facultatives.

Option Type Rôle
lang string Langue du formulaire ('fr', 'en'…). Par défaut, la langue du navigateur si le formulaire la propose, sinon sa langue par défaut. Elle sert aussi pour l'accusé de réception.
publicUrl string Adresse de votre domaine personnalisé, par exemple 'https://formulaires.votre-site.fr'. Par défaut https://canardform.app.
classes object Vos classes CSS, par élément : form, field, error, success, closed, unavailable, submit (voir Classes CSS).
messages object Textes de secours quand le formulaire n'en fournit pas : submit, success, closed, unavailable, error, next, previous.
onSubmitted (idReponse, formulaire) => void Appelée après un envoi réussi. Par défaut, le formulaire est remplacé par le message de remerciement.
onError (erreur, formulaire) => void Appelée quand l'envoi est refusé (champ invalide, formulaire fermé…). Par défaut, le message s'affiche sous le formulaire.
beforeSubmit (donnees: FormData) => FormData | void Ajoute ou modifie des données juste avant l'envoi : champ caché, identifiant de campagne, source UTM… Peut être asynchrone.
renderField (champ, element) => HTMLElement | void Remplace le rendu d'un champ. Renvoyez undefined pour garder le rendu par défaut.
idempotencyKey string Clé anti-doublon de l'envoi. Générée automatiquement : à ne fournir que si vous gérez vous-même les nouvelles tentatives.
fetch typeof fetch Fonction fetch à utiliser à la place de celle du navigateur (tests, proxy).

mountForm renvoie une promesse avec :

  • definition : le formulaire publié tel qu'il a été lu (champs, langue, textes) ;
  • element : l'élément <form> construit ;
  • destroy() : retire le formulaire de la page.

Exemple complet :

import { mountForm } from '@canardform/sdk';

const { destroy } = await mountForm('#form', 'VOTRE_FORMULAIRE', {
    lang: 'fr',
    classes: { form: 'grid gap-4', submit: 'btn btn-primary' },
    messages: { success: 'Merci, nous vous répondons sous 24 h.' },
    beforeSubmit: (data) => {
        data.set(
            'source',
            new URLSearchParams(location.search).get('utm_source') ?? '',
        );
    },
    onSubmitted: (id) => {
        window.location.href = '/merci';
    },
    onError: (error) => {
        console.warn(error.message);
    },
});

Pour que beforeSubmit enregistre une valeur, le formulaire doit contenir un champ avec cette clé, en général un champ caché. Un champ caché lit déjà seul le paramètre de l'adresse de la page : beforeSubmit sert pour une valeur que seul votre site connaît (identifiant de client, panier…).

Composant CanardForm (React et Vue)

<CanardForm> construit le formulaire complet, comme mountForm.

Prop React Attribut Vue Rôle
formId form-id Identifiant du formulaire (obligatoire).
lang lang Langue du formulaire.
publicUrl public-url Adresse de votre domaine personnalisé.
definition :definition Formulaire déjà lu sur le serveur avec getForm(), pour un affichage immédiat (SSR).
classes :classes Vos classes CSS, par élément (voir Classes CSS).
messages :messages Textes de secours : submit, success, closed, unavailable, next, previous.
onSubmitted @submitted Appelée avec l'identifiant de la réponse après un envoi réussi.
renderField slot #field Remplace le rendu d'un champ (voir ci-dessous).
loading slot #loading Contenu affiché pendant le chargement du formulaire.
fetch :fetch Fonction fetch personnalisée.
idempotencyKey Clé anti-doublon (React uniquement, générée automatiquement sinon).

Remplacer un champ en React : renderField reçoit { field, error, children }, où children est le rendu par défaut. Renvoyez undefined pour le garder. <FieldInput field={field} /> donne le contrôle seul, sans libellé.

import { CanardForm, FieldInput } from '@canardform/sdk/react';

<CanardForm
    formId="VOTRE_FORMULAIRE"
    renderField={({ field, error }) =>
        field.key === 'message' ? (
            <label className="block">
                {field.label}
                <FieldInput field={field} />
                {error && <span className="text-red-600">{error}</span>}
            </label>
        ) : undefined
    }
/>;

Slots Vue :

  • #field="{ field, error, input }" : remplace le rendu d'un champ. input() donne le contrôle seul. Un slot qui ne rend rien pour un champ garde le rendu par défaut.
  • #loading : pendant le chargement.
  • #success="{ submissionId }" : à la place du message de remerciement.
  • #closed : à la place du message « formulaire fermé ».
  • #unavailable : si le formulaire ne peut pas être chargé.

Hook et composable useCanardForm

useCanardForm(idFormulaire, options) (depuis @canardform/sdk/react ou @canardform/sdk/vue) gère l'état, les conditions, les étapes, la vérification anti-robot et l'envoi. Vous écrivez tout le HTML. Options : lang, publicUrl, definition, fetch, idempotencyKey.

Il renvoie (en Vue, les valeurs d'état sont des ref, à lire avec .value dans le script) :

Valeur Rôle
definition Le formulaire publié (champs, textes, langue), null pendant le chargement.
status 'idle', 'sending', 'sent' ou 'error'.
errors Première erreur de chaque champ refusé, par clé : errors.email.
error Message général (formulaire fermé, problème réseau…).
submissionId Identifiant de la réponse après l'envoi.
unavailable true si le formulaire n'a pas pu être chargé : affichez un message de secours.
steps, step Les étapes à parcourir (celles qui ont au moins un champ visible) et l'index de l'étape en cours.
handleSubmit À brancher sur l'envoi du <form>.
handleChange À brancher sur onChange (React) ou @input (Vue) : met à jour les conditions d'affichage.
isVisible(cle) Le champ doit-il être affiché selon les réponses en cours ?
isStep(cle) L'étape est-elle celle affichée ?
next(element) Vérifie les champs de l'étape en cours, puis passe à la suivante.
previous() Revient à l'étape précédente.
captchaRef À poser sur un élément vide dans le formulaire : la vérification anti-robot s'y affiche si nécessaire.
submit(donnees) Envoie un objet ou un FormData sans passer par le <form>.
reset() Revient à l'état initial (par exemple pour envoyer une autre réponse).

Pour une autre bibliothèque (Svelte, Angular, Solid…), createFormController(idFormulaire, options) depuis @canardform/sdk/controller fournit les mêmes fonctions, avec getState() et subscribe(listener) pour suivre l'état.

Fonctions getForm et submitForm

Ces deux fonctions marchent dans le navigateur comme sur un serveur (Node.js, Next.js, Nuxt, fonctions serverless).

import { getForm, submitForm, CanardFormError } from '@canardform/sdk';

// Lire le formulaire publié (champs, étapes, textes, langue)
const form = await getForm('VOTRE_FORMULAIRE', { lang: 'fr' });

// Envoyer une réponse : un objet, ou un FormData pour les fichiers
try {
    const id = await submitForm('VOTRE_FORMULAIRE', {
        nom: 'Camille',
        email: 'camille@exemple.fr',
    });
} catch (error) {
    if (error instanceof CanardFormError) {
        console.log(error.error, error.status, error.errors);
    }
}
  • Options de getForm et submitForm : lang, publicUrl, fetch, et idempotencyKey pour submitForm.
  • CanardFormError porte le code stable (error, voir Réponses et codes d'erreur), le statut HTTP (status) et les erreurs par champ (errors).
  • Si le formulaire exige la vérification anti-robot, un envoi depuis un serveur sera refusé : utilisez submitForm dans le navigateur, avec le widget hCaptcha.

Classes CSS

Le SDK pose ces classes par défaut, que vous pouvez styler ou remplacer avec l'option classes :

Élément Classe par défaut Clé de classes
Le <form> cf-form form
Chaque champ (libellé, contrôle, aide, erreur) cf-field field
Message d'erreur cf-error error
Message de remerciement cf-success success
Message « formulaire fermé » cf-closed closed
Message de secours (formulaire injoignable) cf-unavailable unavailable
Bouton d'envoi cf-submit submit

Une classe passée dans classes remplace la classe par défaut de cet élément.

Sans le SDK : formulaire HTML ou fetch

Si vous ne pouvez pas charger de JavaScript, ou si vous voulez écrire tout le code vous-même, envoyez les réponses directement à l'adresse du formulaire. Dans ce cas, c'est à vous de reproduire les champs, la vérification anti-robot et les messages. Une modification du formulaire dans Canard Form demande alors de modifier votre code.

Adresse du formulaire

Chaque formulaire a une adresse publique :

https://canardform.app/v1/f/VOTRE_FORMULAIRE
  • GET avec l'en-tête Accept: application/json renvoie la définition publiée (étapes, champs, options, conditions).
  • POST envoie une réponse.

Avec un domaine personnalisé, l'adresse devient https://formulaires.votre-site.fr/v1/f/VOTRE_FORMULAIRE. Pour le SDK, passez alors l'option publicUrl: 'https://formulaires.votre-site.fr'.

Formulaire HTML sans JavaScript

Le plus simple : un formulaire HTML classique. Le name de chaque champ est la clé du champ (visible dans les Réglages avancés de l'éditeur).

<form action="https://canardform.app/v1/f/VOTRE_FORMULAIRE" method="POST">
    <label
        >Nom
        <input type="text" name="nom" required />
    </label>
    <label
        >E-mail
        <input type="email" name="email" required />
    </label>
    <label
        >Message
        <textarea name="message" required></textarea>
    </label>
    <input type="hidden" name="_redirect" value="https://votre-site.fr/merci" />
    <input
        type="text"
        name="_hp"
        style="display:none"
        tabindex="-1"
        autocomplete="off"
    />
    <button type="submit">Envoyer</button>
</form>
  • _redirect (facultatif) : la page de votre site affichée après l'envoi (voir La page affichée après l'envoi).
  • _hp : un champ piège invisible. S'il est rempli, l'envoi est rejeté comme spam.
  • Cases à cocher multiples : name="cle[]", une case par option, avec la valeur de l'option.
  • Fichiers : ajoutez enctype="multipart/form-data" au <form>.
  • En cas d'erreur, la page Canard Form du formulaire s'affiche avec les erreurs et les valeurs saisies.

Avec ce mode, les étapes s'affichent sur une seule page et les champs conditionnels doivent rester facultatifs. La vérification anti-robot demande JavaScript : choisissez la protection Standard ou Renforcée (voir Protection contre le spam), ou ajoutez le widget hCaptcha décrit plus bas.

La page affichée après l'envoi

Après un envoi réussi, le navigateur du visiteur est renvoyé vers l'adresse de _redirect si toutes ces conditions sont réunies :

  • c'est une adresse complète, en https:// (ou http://) ;
  • son domaine est exactement celui de la page qui contient le formulaire : www.monsite.fr et monsite.fr sont deux domaines différents ;
  • le navigateur indique d'où vient l'envoi. Il le fait de lui-même (en-tête Origin, sinon Referer), sauf si votre site l'en empêche avec Referrer-Policy: no-referrer.

Sinon, le visiteur voit la page de remerciement Canard Form. La réponse est enregistrée dans tous les cas. En cas d'erreur (champ manquant, fichier trop lourd…), il n'y a pas de redirection : la page du formulaire s'affiche avec les erreurs et ce que la personne avait saisi.

Pourquoi cette règle : sans elle, n'importe qui pourrait se servir d'une adresse Canard Form pour renvoyer vos visiteurs vers un site piégé. Un pirate peut bien sûr envoyer de faux en-têtes depuis son propre programme, mais la redirection ne s'applique alors qu'à lui-même : le navigateur d'un visiteur, lui, indique toujours la vraie page d'origine.

Avec le SDK ou fetch, _redirect n'est pas utilisé : la réponse est en JSON. Redirigez vous-même dans onSubmitted (voir Options de mountForm).

Envoyer en JavaScript avec fetch

Pour rester sur la page et afficher votre propre message :

<form id="contact">
    <input type="text" name="nom" required />
    <input type="email" name="email" required />
    <textarea name="message" required></textarea>
    <button type="submit">Envoyer</button>
    <p id="result"></p>
</form>

<script>
    const form = document.getElementById('contact');
    const result = document.getElementById('result');

    form.addEventListener('submit', async (event) => {
        event.preventDefault();
        const response = await fetch(
            'https://canardform.app/v1/f/VOTRE_FORMULAIRE',
            {
                method: 'POST',
                headers: {
                    Accept: 'application/json',
                    'Idempotency-Key': crypto.randomUUID(),
                },
                body: new FormData(form),
            },
        );
        if (response.ok) {
            form.reset();
            result.textContent = 'Merci, votre message est bien envoyé.';
        } else {
            result.textContent = 'Vérifiez les champs et réessayez.';
        }
    });
</script>

L'en-tête Accept: application/json est obligatoire pour recevoir une réponse JSON plutôt qu'une redirection. Envoyez le corps en FormData (obligatoire avec des fichiers) ou en JSON avec Content-Type: application/json.

Vérification anti-robot (hCaptcha)

Si le formulaire utilise la Vérification anti-robot (réglage par défaut, voir Protection contre le spam), chaque envoi doit contenir un jeton hCaptcha.

  • Avec le SDK, le widget est affiché automatiquement (ou à l'emplacement de captchaRef).
  • Avec le HTML ou fetch, ajoutez le widget dans le formulaire. La clé publique (data-sitekey) figure dans le code de l'onglet Intégrations :
<div class="h-captcha" data-sitekey="CLE_PUBLIQUE"></div>
<script src="https://js.hcaptcha.com/1/api.js" async defer></script>

Le widget ajoute le champ h-captcha-response au formulaire. Sans jeton valide, l'envoi est refusé avec le code captcha_failed.

Réponses et codes d'erreur

Avec Accept: application/json :

Statut Corps Signification
201 {"submission_id": "…"} Réponse enregistrée
200 {"submission_id": "…"} Même Idempotency-Key déjà reçue : rien n'est enregistré deux fois
422 {"error": "validation_failed", "errors": {…}} Champs invalides, avec un message par champ
422 {"error": "captcha_failed"} Vérification anti-robot absente ou invalide
422 {"error": "spam_rejected"} Champ piège _hp rempli
410 {"error": "form_closed"} Formulaire désactivé, archivé ou hors de ses dates
403 {"error": "quota_exceeded"} Limite de réponses du mois atteinte
403 {"error": "origin_not_allowed"} Site absent des sites autorisés du formulaire
403 {"error": "storage_quota_exceeded"} Espace de stockage des fichiers plein
409 {"error": "idempotency_conflict"} Même Idempotency-Key avec un contenu différent
409 {"error": "idempotency_in_progress"} Même Idempotency-Key encore en cours de traitement, réessayez dans un instant
429 Trop d'envois depuis la même adresse
500 {"error": "technical_error", "reference": "…"} Erreur technique, à signaler avec la référence

Idempotency-Key : envoyez une valeur unique par tentative (par exemple crypto.randomUUID()) et réutilisez-la si vous renvoyez la même réponse après une coupure réseau. Sans cet en-tête, un double clic dans la même minute est quand même dédoublonné.

Fichiers

Envoyez les fichiers en multipart/form-data, avec la clé du champ comme name (name="cv", ou name="pieces[]" pour plusieurs fichiers). Les types acceptés, le nombre de fichiers et le poids maximal sont ceux réglés dans le champ Fichier (voir Le champ Fichier).

Content Security Policy

Si votre site envoie un en-tête Content-Security-Policy, autorisez :

  • canardform.app (ou votre domaine personnalisé) dans connect-src et form-action, et dans frame-src pour l'intégration par iframe ;
  • https://hcaptcha.com https://*.hcaptcha.com dans script-src, frame-src, style-src et connect-src si le formulaire utilise la vérification anti-robot ;
  • https://cdn.jsdelivr.net dans script-src seulement si vous chargez le SDK depuis le CDN.

Intégration avec un agent IA

Dans Intégrations → Avec un agent IA, cliquez sur Copier le prompt et collez-le dans l'agent de votre projet (Claude Code, Cursor, Copilot…). Le prompt contient l'identifiant du formulaire, ses champs et ses étapes, l'intégration à choisir selon votre stack et les vérifications à faire. L'agent détecte votre framework et ajoute le formulaire en suivant les conventions du projet.

Documentation du SDK

La documentation complète du SDK (options, types, rendu personnalisé, SSR) est sur canardform.github.io/sdk-js. Le SDK est open source. Pour lire les réponses depuis votre serveur, utilisez l'API.