Passer au contenu principal
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 avec une clé API
  • Une application Base44 sur le plan Builder 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 : 
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 : 
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://<your-app-domain>/functions/<function-name>
  3. Firma envoie des événements pour les changements d’état clés, consultez le guide des webhooks pour tous les types d’événements
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 :
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 pour connaître la dernière version.
  1. 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 : 
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 : 
<iframe
  src="https://app.firma.dev/signing/{signing_request_user_id}"
  style="width:100%;height:900px;border:0;"
  allow="camera;microphone;clipboard-write"
  title="Document Signing"
></iframe>
Consultez le guide de signature intégrée 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 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