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

# Claude Code

> Ajoutez des signatures électroniques juridiquement valables à n'importe quel projet grâce à Claude Code et aux serveurs MCP de Firma.

Firma vous permet d'ajouter des signatures électroniques juridiquement valables à tout ce que vous construisez avec Claude Code. Connectez les serveurs MCP de Firma et Claude Code pourra générer du code d'intégration Firma précis, gérer vos demandes de signature et opérer directement sur vos données Firma depuis le terminal ou votre IDE.

## Prérequis

* Un [compte Firma](https://app.firma.dev) avec une clé API
* Claude Code installé ([CLI](https://docs.anthropic.com/en/docs/claude-code), [extension VS Code](https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code), ou [plugin JetBrains](https://plugins.jetbrains.com/plugin/claude-code))
* Au moins un modèle Firma avec des champs de signature configurés

<Note>
  Firma utilise la clé API brute comme valeur de l'en-tête `Authorization` - ne la préfixez pas avec `Bearer`. Cela diffère de nombreuses autres API.
</Note>

## Pour commencer

### Étape 1 : Ajouter les serveurs MCP de Firma

Ajoutez les deux serveurs MCP de Firma aux paramètres de votre projet. À la racine de votre projet, créez ou modifiez `.claude/settings.json` :

```json theme={null}
{
  "mcpServers": {
    "firma-api": {
      "type": "url",
      "url": "https://mcp.firma.dev/mcp"
    },
    "firma-docs": {
      "type": "url",
      "url": "https://docs.firma.dev/mcp"
    }
  }
}
```

Vous pouvez également les ajouter à vos paramètres utilisateur dans `~/.claude/settings.json` pour les rendre disponibles sur tous vos projets.

* **firma-api** donne à Claude Code un accès direct à l'API Firma - 84 outils couvrant les demandes de signature, les modèles, les espaces de travail et les webhooks.
* **firma-docs** donne à Claude Code accès à l'ensemble de la documentation Firma afin qu'il génère du code d'intégration précis.

Redémarrez Claude Code après avoir enregistré la configuration. Lors de la première utilisation d'un outil de l'API Firma, Claude Code vous guidera pour vous connecter à votre compte Firma via OAuth.

<Note>
  Quand utiliser quel serveur : `firma-api` sert à faire des actions (envoyer des demandes de signature, gérer des modèles). `firma-docs` sert à construire des choses (générer du code d'intégration avec des détails d'API précis). La plupart des développeurs voudront connecter les deux.
</Note>

### Étape 2 : Utiliser Firma depuis Claude Code

Une fois connecté, vous pouvez demander à Claude Code de construire des intégrations Firma ou d'opérer sur vos données :

**Générer une intégration backend :**

```text theme={null}
Using the Firma API docs, create an Express route that:
1. Accepts a name, template_id, signer email, and signer name
2. Uses the create-and-send endpoint to send a signing request
3. Returns the signing request ID and the signer's signing link
Store the API key in process.env.FIRMA_API_KEY.
```

**Lister vos demandes de signature :**

```text theme={null}
List all pending signing requests in my default workspace.
```

**Envoyer une demande de signature :**

```text theme={null}
Create a signing request from the NDA template and send it to jane@example.com
```

**Ajouter la signature intégrée à une application React :**

```text theme={null}
Using the Firma docs, add an embedded signing view to this React app.
After a signing request is created, render the signer's signing_link
in an iframe.
```

**Configurer des webhooks :**

```text theme={null}
Using the Firma docs, create a webhook handler that listens for
signing_request.completed events and updates the contract status
in our Postgres database.
```

Faire explicitement référence à « the Firma docs » indique à Claude Code d'interroger le serveur MCP `firma-docs` avant d'écrire du code. Sans cela, il peut se rabattre sur des connaissances générales et manquer des détails sur les points de terminaison ou l'authentification.

## Ce que génère Claude Code

Lorsque vous demandez à Claude Code de construire une intégration Firma, le code backend généré devrait ressembler à ceci :

```typescript theme={null}
import express from "express";

const FIRMA_API = "https://api.firma.dev/functions/v1/signing-request-api";
const app = express();
app.use(express.json());

app.post("/api/signing-requests", async (req, res) => {
  const { name, template_id, signer_email, signer_first_name, signer_last_name } =
    req.body;

  const response = await fetch(
    `${FIRMA_API}/signing-requests/create-and-send`,
    {
      method: "POST",
      headers: {
        Authorization: process.env.FIRMA_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        name,
        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 res.status(response.status).json({ error: data });
  res.json({
    signing_request_id: data.id,
    signing_request_user_id: data.first_signer.id,
    signing_link: data.first_signer.signing_link,
  });
});

app.listen(3000);
```

Le point de terminaison `create-and-send` crée la demande de signature et l'envoie aux destinataires de manière atomique. Si vous avez besoin de vérifier ou de modifier la demande avant l'envoi, utilisez `POST /signing-requests` pour créer un brouillon, puis `POST /signing-requests/{id}/send` séparément.

<Warning>
  N'exposez jamais votre clé API dans du code frontend. Appelez toujours l'API Firma depuis un backend où les secrets restent protégés.
</Warning>

## Intégration des webhooks

Pour suivre les événements de signature en temps réel, demandez à Claude Code d'ajouter un gestionnaire de webhook :

```text theme={null}
Using the Firma docs, create a webhook handler that receives Firma events.
When signing_request.completed fires, update the contract record in the database.
```

L'agent générera quelque chose comme ceci :

```typescript theme={null}
app.post("/api/firma-webhook", async (req, res) => {
  const { type, data } = req.body;

  if (type === "signing_request.completed") {
    const signingRequestId = data.signing_request.id;
    // Update your database or trigger the next workflow step.
  }

  res.json({ received: true });
});
```

Dans le tableau de bord Firma, sous **Paramètres > Webhooks**, enregistrez l'URL de votre point de terminaison. Firma envoie des événements pour tous les changements d'état majeurs. Consultez le [guide des webhooks](/fr/guides/webhooks) pour la liste complète des événements et la vérification de signature.

<Warning>
  Vérifiez toujours la signature du webhook à l'aide de votre secret de signature webhook Firma en production. Consultez le [guide des webhooks](/fr/guides/webhooks) pour les détails d'implémentation.
</Warning>

## Signature intégrée

Pour les applications où les signataires complètent des documents directement dans votre interface plutôt que d'ouvrir une page hébergée par Firma, la réponse de `create-and-send` inclut `first_signer.id` (le `signing_request_user_id`) et un `first_signer.signing_link` prêt à l'emploi. Chargez l'URL du signataire dans une iframe :

```html theme={null}
<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 la signature intégrée](/fr/guides/embeddable-signing) pour la configuration complète, y compris les bonnes pratiques de sécurité.

## Conseils

* **Utilisez `firma-docs` pour construire, `firma-api` pour opérer.** Le serveur de documentation aide Claude Code à écrire du code d'intégration correct. Le serveur API lui permet de gérer directement les demandes de signature, les modèles et les espaces de travail.
* **Passez `template_id` explicitement.** Les modèles sont le moyen le plus sûr de limiter ce que l'agent peut envoyer.
* **Validez avant l'envoi.** Pour les documents à enjeux plus élevés, demandez à Claude Code de créer un brouillon avec `POST /signing-requests`, puis de confirmer avant d'appeler `POST /signing-requests/{id}/send`.
* **Espaces de travail pour les applications multi-tenant.** Si vous construisez un produit SaaS, attribuez à chaque client final son propre espace de travail Firma afin que les modèles et l'utilisation restent isolés.

## Prochaines étapes

* [Authentification API](/fr/guides/authentication) - Clés API et portée des espaces de travail
* [Guide des webhooks](/fr/guides/webhooks) - Types d'événements, payloads et vérification de signature
* [Signature intégrée](/fr/guides/embeddable-signing) - Expérience de signature intégrée à l'application
* [Création d'espaces de travail](/fr/guides/creating-workspaces) - Configurations multi-tenant pour applications SaaS
* [Intégration MCP](/fr/guides/mcp) - Référence complète du serveur MCP avec les 84 outils
* [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