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
mountFormsur 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.renderFieldremplace le rendu d'un champ par votre composant.- Le hook
useCanardFormvous 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.captchaRefplace 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
getFormetsubmitForm:lang,publicUrl,fetch, etidempotencyKeypoursubmitForm. CanardFormErrorporte 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
submitFormdans 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
GETavec l'en-têteAccept: application/jsonrenvoie la définition publiée (étapes, champs, options, conditions).POSTenvoie 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://(ouhttp://) ; - son domaine est exactement celui de la page qui contient le formulaire :
www.monsite.fretmonsite.frsont deux domaines différents ; - le navigateur indique d'où vient l'envoi. Il le fait de lui-même (en-tête
Origin, sinonReferer), sauf si votre site l'en empêche avecReferrer-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é) dansconnect-srcetform-action, et dansframe-srcpour l'intégration par iframe ;https://hcaptcha.com https://*.hcaptcha.comdansscript-src,frame-src,style-srcetconnect-srcsi le formulaire utilise la vérification anti-robot ;https://cdn.jsdelivr.netdansscript-srcseulement 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.