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

# Cursor

> Ajoutez des signatures électroniques juridiquement contraignantes à n'importe quel projet grâce aux fonctionnalités IA de Cursor et à l'API Firma.

Firma se connecte à Cursor via deux serveurs MCP : l'un vous permet de gérer les demandes de signature, les modèles et les espaces de travail directement depuis l'éditeur, et l'autre donne à l'IA de Cursor accès à la documentation de Firma afin qu'elle puisse générer du code d'intégration précis. Ce guide couvre les deux.

## Prérequis

* Un [compte Firma](https://app.firma.dev) avec une clé API
* [Cursor](https://cursor.com) installé avec la prise en charge de MCP
* 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>

## Connecter le serveur MCP Firma Data

Le serveur MCP Data donne à Cursor un accès direct à l'API Firma. Une fois connecté, vous pouvez gérer les demandes de signature, les modèles, les webhooks et les espaces de travail en langage naturel dans Composer ou Chat.

### Installation en un clic

Utilisez le bouton d'installation en un clic sur la [page d'intégration MCP Firma](/fr/guides/mcp) pour ajouter automatiquement le serveur à Cursor.

### Configuration manuelle

Ajoutez ce qui suit à votre configuration au niveau du projet dans `.cursor/mcp.json`, ou à votre configuration au niveau utilisateur dans `~/.cursor/mcp.json` :

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

Redémarrez Cursor après l'enregistrement. La première fois que vous utilisez un outil Firma, Cursor vous guidera pour vous connecter à votre compte Firma via OAuth.

Une fois connecté, vous pouvez demander à Cursor des choses comme :

* « Montre-moi toutes les demandes de signature en attente dans mon espace de travail »
* « Crée une demande de signature à partir du modèle NDA et envoie-la à [jane@example.com](mailto:jane@example.com) »
* « Configure un webhook pour les événements signing\_request.completed »

Le serveur MCP Data expose 84 outils couvrant les demandes de signature, les modèles, les espaces de travail, les webhooks, la configuration des e-mails, et plus encore. Consultez la [référence complète des outils](/guides/mcp#available-tools) pour la liste complète.

## Connecter le serveur MCP Firma Docs

Le serveur MCP Docs donne à l'IA de Cursor accès à la documentation de Firma. C'est ce qui permet à Composer et à Chat de générer du code d'intégration Firma précis, car ils peuvent consulter les endpoints, les formats de requête et les détails d'authentification en temps réel plutôt que de deviner.

Ajoutez-le à côté du serveur Data dans votre `.cursor/mcp.json`. Les deux entrées sont des serveurs MCP distincts : `firma-api` pour les actions en temps réel sur l'API Firma, et `firma-docs` pour les recherches documentaires :

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

Redémarrez Cursor après l'enregistrement.

<Note>
  **Quand utiliser quel serveur :** le serveur MCP Data (`firma-api`) sert à faire des choses (envoyer des demandes de signature, gérer des modèles). Le serveur MCP Docs (`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>

## Générer une intégration Firma avec Composer

Avec les deux serveurs MCP connectés, le Composer de Cursor peut générer du code d'intégration Firma fonctionnel pour votre projet. Voici des exemples de prompts qui fonctionnent bien :

### Endpoint backend pour l'envoi de demandes de signature

```text theme={null}
Using the Firma API docs, create a Next.js API route that:
1. Accepts a 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 status
Store the API key in an environment variable called FIRMA_API_KEY.
```

Composer va parcourir la documentation Firma, trouver l'endpoint correct (`POST /signing-requests/create-and-send`), et générer une route API complète utilisant la bonne URL de base, les bons en-têtes et le bon format de corps de requête.

### Signature intégrée dans 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, show the signing experience
in an iframe. Use the signing_request_user_id from the API response.
```

### Gestionnaire de webhook pour les signatures terminées

```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 database.
```

### Intégration complète à partir de zéro

```text theme={null}
I need to add e-signatures to this app. Users should be able to:
1. Pick a contract template
2. Enter the signer's name and email
3. Send the contract for signing
4. See when the contract has been signed

Use the Firma API for all of this. Check the Firma docs for
the correct endpoints and request formats.
```

## Exemple : route API Next.js

Voici ce que Composer génère généralement pour un endpoint Next.js de demande de signature. Vous pouvez l'utiliser comme référence ou point de départ :

```typescript theme={null}
// app/api/sign/route.ts
import { NextRequest, NextResponse } from "next/server";

const FIRMA_API = "https://api.firma.dev/functions/v1/signing-request-api";

export async function POST(req: NextRequest) {
  const { template_id, signer_email, signer_first_name, signer_last_name } =
    await req.json();

  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({
        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 NextResponse.json({ error: data }, { status: response.status });
  }

  return NextResponse.json({
    signing_request_id: data.id,
    status: "sent",
  });
}
```

<Note>
  L'endpoint `create-and-send` crée la demande de signature et l'envoie aux destinataires en un seul appel. Si vous devez examiner ou modifier la demande avant de l'envoyer, utilisez `POST /signing-requests` pour créer un brouillon, puis `POST /signing-requests/{id}/send` séparément.
</Note>

Stockez votre clé API dans `.env.local` (ou l'équivalent de votre projet) :

```bash theme={null}
FIRMA_API_KEY=your_api_key_here
```

<Warning>
  N'exposez jamais votre clé API dans du code frontend. Appelez toujours l'API Firma depuis des routes côté serveur ou des fonctions backend.
</Warning>

## 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. La réponse `create-and-send` inclut un `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 signature intégrée](/fr/guides/embeddable-signing) pour les instructions de configuration complètes, y compris les bonnes pratiques de sécurité.

## Conseils pour travailler avec Cursor + Firma

* **Soyez précis dans vos prompts.** « Utilise l'endpoint create-and-send de Firma » donne de meilleurs résultats que « ajoute des signatures électroniques ». Le serveur MCP Docs aide, mais des prompts précis produisent toujours un code plus exact.
* **Référencez explicitement la documentation.** Commencer un prompt par « En utilisant la documentation Firma » ou « Vérifie la documentation de l'API Firma » indique à Composer d'interroger le serveur MCP Docs avant de générer du code.
* **Utilisez le mode Agent pour les modifications multi-fichiers.** Si vous ajoutez la signature à une application existante, le mode Agent de Composer peut créer la route API, mettre à jour le frontend et ajouter des variables d'environnement dans plusieurs fichiers en une seule fois.
* **Testez avec le serveur MCP Data.** Après avoir généré votre code d'intégration, vous pouvez utiliser le serveur MCP Data pour envoyer des demandes de signature de test directement depuis le chat de Cursor, sans quitter l'éditeur.

## Étapes suivantes

* [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, charges utiles et vérification de signature
* [Signature intégrée](/fr/guides/embeddable-signing) — expérience de signature dans l'application
* [Création d'espaces de travail](/fr/guides/creating-workspaces) — configurations multi-locataires pour les 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 endpoints