> ## Documentation Index
> Fetch the complete documentation index at: https://docs.firma.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# Base44
> Ajoutez des signatures électroniques juridiquement valables à toute application Base44 grâce aux fonctions backend ou à une intégration OpenAPI au niveau de l'espace de travail.
Firma vous permet d'ajouter des signatures électroniques juridiquement valables à toute application Base44. Utilisez les fonctions backend de Base44 pour appeler l'API Firma, gérer les modèles, envoyer des demandes de signature et suivre les finalisations via des webhooks.
Ce guide couvre deux approches d'intégration :
1. **Fonctions backend** (par application) — Écrivez des fonctions TypeScript qui appellent directement l'API REST de Firma. Idéal pour les applications uniques ou la logique personnalisée.
2. **Intégration OpenAPI personnalisée** (au niveau de l'espace de travail) — Importez la spécification OpenAPI de Firma une seule fois et laissez chaque application de votre espace de travail appeler les points de terminaison Firma via `base44.integrations.custom.call()`. Idéal pour les équipes gérant plusieurs applications.
## Prérequis
* Un [compte Firma](https://app.firma.dev) avec une clé API
* Une application Base44 sur le plan [Builder](https://base44.com/pricing) ou supérieur (requis pour les fonctions backend et les intégrations personnalisées)
* Au moins un modèle Firma avec des champs de signature configurés
## Approche 1 : fonctions backend
C'est l'approche la plus flexible. Vous écrivez des fonctions TypeScript dans votre application Base44 qui appellent directement l'API REST de Firma.
### Étape 1 : stocker votre clé API en tant que secret
1. Ouvrez votre application dans l'éditeur Base44
2. Allez dans **tableau de bord → Secrets**
3. Cliquez sur **Add Secret**
4. Définissez le nom sur `FIRMA_API_KEY` et collez votre clé API Firma comme valeur
N'exposez jamais votre clé API dans le code frontend. Appelez toujours l'API Firma depuis des fonctions backend où les secrets restent en sécurité.
### Étape 2 : créer une fonction backend pour envoyer des demandes de signature
Créez une nouvelle fonction sous **tableau de bord → Code → Functions**, ou demandez au chat IA de Base44 d'en générer une.
Cet exemple crée une demande de signature à partir d'un modèle et l'envoie en un seul appel API grâce au point de terminaison `create-and-send` :
```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";
const FIRMA_API = "https://api.firma.dev/functions/v1/signing-request-api";
Deno.serve(async (req) => {
const base44 = createClientFromRequest(req);
const user = await base44.auth.me();
if (!user) {
return Response.json({ error: "Unauthorized" }, { status: 401 });
}
const { template_id, signer_email, signer_first_name, signer_last_name } =
await req.json();
const apiKey = Deno.env.get("FIRMA_API_KEY");
// Create and send a signing request from a template in one call
const response = await fetch(
`${FIRMA_API}/signing-requests/create-and-send`,
{
method: "POST",
headers: {
Authorization: apiKey,
"Content-Type": "application/json",
},
body: JSON.stringify({
template_id,
recipients: [
{
first_name: signer_first_name,
last_name: signer_last_name,
email: signer_email,
designation: "Signer",
order: 1,
},
],
}),
}
);
const data = await response.json();
if (!response.ok) {
return Response.json({ error: data }, { status: response.status });
}
return Response.json({
signing_request_id: data.id,
status: "sent",
});
});
```
Le point de terminaison `create-and-send` crée la demande de signature et l'envoie aux destinataires de manière atomique. Si vous devez examiner ou modifier la demande avant l'envoi, utilisez `POST /signing-requests` pour créer un brouillon, puis `POST /signing-requests/{id}/send` séparément.
### Étape 3 : connecter la fonction à l'interface de votre application
Appelez la fonction backend depuis votre frontend en utilisant le SDK Base44 :
```typescript theme={null}
import { base44 } from "@/api/base44Client";
const response = await base44.functions.invoke("sendSigningRequest", {
template_id: "your-template-id",
signer_email: "alice@example.com",
signer_first_name: "Alice",
signer_last_name: "Johnson",
});
```
Vous pouvez également demander au chat IA de Base44 de configurer cela pour vous, par exemple : *"Lorsque l'utilisateur clique sur 'Send Contract', appelle la fonction sendSigningRequest avec l'ID du modèle, l'email du signataire et le nom depuis le formulaire."*
### Intégration webhook
Pour suivre le moment où les documents sont signés, configurez un webhook Firma qui pointe vers une fonction backend Base44.
1. Créez une nouvelle fonction backend pour gérer les événements webhook entrants
2. Dans le tableau de bord Firma, sous **Paramètres → Webhooks**, enregistrez un webhook pointant vers l'URL de votre fonction : `https:///functions/`
3. Firma envoie des événements pour les changements d'état clés, consultez le [guide des webhooks](/fr/guides/webhooks) pour tous les types d'événements
```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";
Deno.serve(async (req) => {
const base44 = createClientFromRequest(req);
const payload = await req.json();
const { type, data } = payload;
if (type === "signing_request.completed") {
const signingRequestId = data.signing_request.id;
// Update your app's database or trigger the next step
// in your workflow using the Base44 entities SDK
}
return Response.json({ received: true });
});
```
## Approche 2 : intégration OpenAPI personnalisée
Si votre espace de travail comporte plusieurs applications ayant besoin de signatures électroniques, enregistrez Firma comme intégration partagée au niveau de l'espace de travail à l'aide de la spécification OpenAPI. Vous configurez l'authentification une seule fois et chaque application peut appeler les points de terminaison Firma sans écrire de fonctions backend.
### Étape 1 : ajouter l'intégration
1. Cliquez sur votre **icône de profil** en haut à droite de votre espace de travail
2. Allez dans **Settings → Integrations**
3. Cliquez sur **New Integration**
4. Sélectionnez **From URL** et saisissez l'URL de la spécification OpenAPI de Firma :
```text theme={null}
https://docs.firma.dev/api-reference/v01.15.00/openapi-v01.15.00.json
```
L'URL de la spécification inclut le numéro de version de l'API. Consultez le [changelog de l'API](/fr/guides/api-changelog) pour connaître la dernière version.
5. Cliquez sur **Continue**
### Étape 2 : sélectionner les points de terminaison
Sélectionnez les points de terminaison dont vos applications auront besoin. Choix courants :
* `POST /signing-requests` — Créer une demande de signature à partir d'un modèle ou d'un document
* `POST /signing-requests/create-and-send` — Créer et envoyer en un seul appel
* `GET /signing-requests/{id}` — Vérifier le statut
* `GET /signing-requests` — Lister les demandes de signature
* `POST /templates/{id}/duplicate` — Dupliquer un modèle dans une demande de signature
* `GET /templates` — Lister les modèles disponibles
Vous pouvez sélectionner jusqu'à 30 points de terminaison.
### Étape 3 : configurer l'authentification
1. Définissez l'**URL de base** sur `https://api.firma.dev/functions/v1/signing-request-api`
2. Sous **Custom Headers**, cliquez sur **Add Header**
3. Définissez le nom de l'en-tête sur `Authorization` et collez votre clé API Firma comme valeur
Base44 stocke ceci en tant que secret chiffré au niveau de l'espace de travail. Il n'atteint jamais le navigateur.
### Étape 4 : utiliser dans vos applications
Une fois configurée, n'importe quelle application de l'espace de travail peut appeler les points de terminaison Firma à l'aide du SDK :
```typescript theme={null}
const result = await base44.integrations.custom.call(
"firma",
"post:/signing-requests/create-and-send",
{
payload: {
template_id: templateId,
recipients: [
{
first_name: "Alice",
last_name: "Johnson",
email: "alice@example.com",
designation: "Signer",
order: 1,
},
],
},
}
);
```
Vous pouvez également demander au chat IA de Base44 de configurer les appels à Firma, il détectera l'intégration de l'espace de travail et l'utilisera automatiquement.
## Signature intégrée
Pour les applications où les signataires complètent les documents directement dans votre interface, Firma propose une expérience de signature intégrable. Une fois que vous avez obtenu le `signing_request_user_id` du destinataire depuis l'API, chargez-le dans un iframe au sein de votre application Base44 :
```html theme={null}
```
Consultez le [guide de signature intégrée](/fr/guides/embeddable-signing) pour les instructions de configuration complètes, y compris les meilleures pratiques de sécurité.
## Bonus : connexion MCP pour la création assistée par IA
Firma propose un [serveur MCP de documentation](/fr/guides/mcp) que vous pouvez connecter à votre compte Base44. Cela permet au chat IA de Base44 de rechercher dans la documentation Firma pendant que vous développez, afin de vous aider à écrire du code d'intégration avec des détails d'API précis.
Pour le configurer :
1. Allez dans **Account Settings → MCP Connections**
2. Ajoutez un nouveau serveur MCP avec l'URL : `https://docs.firma.dev/mcp`
Ceci concerne uniquement l'expérience de développement et n'affecte pas votre application déployée.
## Prochaines étapes
* [Authentification API](/fr/guides/authentication) — clés API et portée de l'espace de travail
* [Guide des webhooks](/fr/guides/webhooks) — types d'événements, charges utiles et vérification de signature
* [Signature intégrée](/fr/guides/embeddable-signing) — expérience de signature intégrée à l'application
* [Créer des espaces de travail](/fr/guides/creating-workspaces) — configurations multi-tenant pour les applications SaaS
* [Guide de configuration complet](/fr/guides/complete-setup-guide) — parcours d'intégration Firma de bout en bout
* [Référence API](/api-reference) — documentation complète des points de terminaison