Comment ajouter des signatures électroniques à votre application Base44

Les applications Base44 gèrent de véritables processus métier : propositions, contrats de service, formulaires d'admission, documents d'intégration. Rien de tout cela ne se conclut proprement sans signature, et Base44 n'en propose pas d'origine. Firma.dev comble cette lacune avec une API de signature électronique que vous pouvez intégrer à n'importe quelle application Base44 en un après-midi, et non en un sprint.

Comment ça marche (sans les détails techniques)

Firma.dev vous offre deux façons de connecter une application Base44, et celle que vous choisirez dépendra du nombre d'applications que vous exécutez.

S'il s'agit d'une seule application, vous écrivez une fonction backend : un petit morceau de TypeScript qui appelle l'API REST de Firma.dev pour créer une demande de signature, l'envoyer et écouter la signature en retour. Base44 conserve votre clé API verrouillée dans un secret, de sorte qu'elle ne touche jamais le navigateur.

Si vous gérez un espace de travail avec plusieurs applications, vous enregistrez Firma.dev une seule fois en tant qu'intégration personnalisée à l'aide de sa spécification OpenAPI. Après cela, chaque application de l'espace de travail peut appeler les points de terminaison de Firma.dev directement via le SDK Base44, sans fonction distincte par application.

Les deux chemins mènent au même résultat : un signataire ouvre le document, le signe de manière intégrée directement dans votre application, et un webhook informe votre backend dès que c'est fait.

Ce dont vous avez besoin au préalable

• Un compte Firma.dev avec une clé API

• Une application Base44 avec le forfait Builder ou supérieur (requis pour les fonctions backend et les intégrations personnalisées)

• Un modèle Firma.dev avec des champs de signature déjà configurés

Chemin 1 : fonctions backend

C'est la voie la plus flexible, et celle vers laquelle se tourner si vous connectez une seule application.

Stockez la clé. Dans l'éditeur Base44, allez dans Dashboard → Secrets, ajoutez un nouveau secret et nommez-le FIRMA_API_KEY. Ne mettez jamais la clé dans le code frontend, seules les fonctions backend doivent la voir.

Écrivez la fonction. Sous Dashboard → Code → Functions, créez une nouvelle fonction (ou demandez au chat IA de Base44 d'en générer une). Voici l'exemple exact de la documentation de Firma.dev, créant et envoyant une demande de signature à partir d'un modèle en un seul appel :

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",
  });
});

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",
  });
});

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",
  });
});

Si vous préférez examiner une demande avant qu'elle ne soit envoyée, la documentation de Firma.dev indique l'alternative : POST /signing-requests pour créer un brouillon, puis POST /signing-requests/{id}/send séparément.

Connectez-le à l'interface utilisateur. Appelez la fonction depuis le frontend avec 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",
});

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",
});

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",
});

Ou dites simplement au chat IA de Base44 ce que vous voulez : "Lorsque l'utilisateur clique sur 'Envoyer le contrat', appelle la fonction sendSigningRequest avec l'ID du modèle, l'e-mail du signataire et le nom figurant dans le formulaire."

Suivez les finalisations avec un webhook. Créez une fonction backend pour recevoir l'événement, puis enregistrez-la dans Firma.dev sous Settings → Webhooks, en pointant vers https://<votre-domaine-d-application>/functions/<nom-de-la-fonction>.

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 });
});

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 });
});

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 });
});

Chemin 2 : intégration OpenAPI au niveau de l'espace de travail

Vous exécutez plus d'une application Base44 ? Configurez cela une seule fois et chaque application de l'espace de travail en héritera.

Depuis l'icône de votre profil, allez dans Settings → Integrations → New Integration → From URL, et collez l'URL de la spécification OpenAPI de Firma.dev (consultez le journal des modifications de l'API de Firma.dev pour la version actuelle). Choisissez les points de terminaison dont vous avez besoin, jusqu'à 30, généralement :

• 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

Pour l'authentification, définissez l'URL de base sur https://api.firma.dev/functions/v1/signing-request-api, puis ajoutez un en-tête personnalisé nommé Authorization avec votre clé API Firma.dev comme valeur. Base44 la chiffre et la stocke au niveau de l'espace de travail, elle ne parvient jamais au navigateur.

À partir de là, n'importe quelle application appelle directement Firma.dev :

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,
        },
      ],
    },
  }
);

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,
        },
      ],
    },
  }
);

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,
        },
      ],
    },
  }
);

Demandez également au chat IA de Base44 de connecter les appels Firma.dev ici, il détecte l'intégration de l'espace de travail et l'utilise de lui-même.

Signature intégrée

Pour les applications où vous souhaitez que le signataire remplisse le document sans quitter votre interface utilisateur, récupérez le signing_request_user_id de la réponse API et chargez-le dans une iframe :

<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>

<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>

<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>

Ce que vous obtenez d'office

Chaque demande de signature construite de cette manière hérite du produit réel de Firma.dev, et non d'un wrapper d'API dépouillé : un éditeur de modèles intégrable pour créer des documents, des espaces de travail client si vous exécutez une application Base44 multi-entité, et une validité juridique dans plus de 55 pays sous SES et AES (conforme à eIDAS ; Firma.dev ne propose pas encore de QES).

La tarification est logique pour les créateurs

Les applications Base44 en sont généralement à leurs débuts, ce qui rend les outils de signature payés par utilisateur inadaptés avant même que vous n'ayez une équipe complète. Firma.dev propose plutôt un tarif par enveloppe : 0,049 € (~5¢), au paiement à l'utilisation, sans minimum mensuel, sans contrat. Par rapport aux tarifs par utilisateur de DocuSign, c'est 97 à 99 % moins cher pour tous les volumes que vous êtes susceptible d'atteindre pendant votre phase de développement.

Envoyez ceci à votre développeur (ou faites-le vous-même)

Les deux chemins ci-dessus sont prêts à être copiés-collés, et la plupart des créateurs sur Base44 auront cela en place en moins d'une heure. Si vous souhaitez que le chat IA s'occupe de l'intégration, orientez-le vers le guide d'intégration Base44 de Firma.dev et il pourra générer directement les fonctions. Firma.dev dispose également d'un serveur MCP de documentation que vous pouvez ajouter sous Paramètres du compte → Connexions MCP afin que le chat IA puisse obtenir des détails précis sur l'API pendant que vous construisez.

Commencez à utiliser Firma.dev gratuitement, sans carte de crédit requise.