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

> Añade firmas electrónicas legalmente vinculantes a cualquier proyecto usando Claude Code con los servidores MCP de Firma.

Firma te permite añadir firmas electrónicas legalmente vinculantes a cualquier cosa que construyas con Claude Code. Conecta los servidores MCP de Firma y Claude Code podrá generar código de integración de Firma preciso, gestionar tus Solicitudes de Firma y operar sobre tus datos de Firma directamente desde la terminal o tu IDE.

## Requisitos previos

* Una [cuenta de Firma](https://app.firma.dev) con una Clave API
* Claude Code instalado ([CLI](https://docs.anthropic.com/en/docs/claude-code), [extensión de VS Code](https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code) o [plugin de JetBrains](https://plugins.jetbrains.com/plugin/claude-code))
* Al menos una Plantilla de Firma con Campos de firma configurados

<Note>
  Firma usa la Clave API sin modificar como valor del encabezado `Authorization`; no la antepongas con `Bearer`. Esto difiere de muchas otras APIs.
</Note>

## Primeros pasos

### Paso 1: Añade los servidores MCP de Firma

Añade ambos servidores MCP de Firma a la configuración de tu proyecto. En la raíz de tu proyecto, crea o edita `.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"
    }
  }
}
```

Alternativamente, añádelos a la configuración de tu usuario en `~/.claude/settings.json` para que estén disponibles en todos tus proyectos.

* **firma-api** le da a Claude Code acceso directo a la API de Firma: 84 herramientas para Solicitudes de Firma, Plantillas, Espacios de Trabajo y webhooks.
* **firma-docs** le da a Claude Code acceso a la documentación completa de Firma para que genere código de integración preciso.

Reinicia Claude Code después de guardar la configuración. La primera vez que uses una herramienta de la API de Firma, Claude Code te guiará para iniciar sesión con tu cuenta de Firma mediante OAuth.

<Note>
  Cuándo usar cada servidor: `firma-api` sirve para hacer cosas (enviar Solicitudes de Firma, gestionar Plantillas). `firma-docs` sirve para construir cosas (generar código de integración con detalles precisos de la API). La mayoría de los desarrolladores querrán tener ambos conectados.
</Note>

### Paso 2: Usa Firma desde Claude Code

Una vez conectado, puedes pedirle a Claude Code que construya integraciones de Firma u opere sobre tus datos:

**Genera una integración de 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.
```

**Lista tus Solicitudes de Firma:**

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

**Envía una Solicitud de Firma:**

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

**Añade firma incrustada a una app de 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.
```

**Configura 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.
```

Referenciar explícitamente "the Firma docs" le indica a Claude Code que consulte el servidor MCP `firma-docs` antes de escribir código. Sin eso, puede recurrir a su conocimiento general y pasar por alto detalles de endpoints o autenticación.

## Lo que genera Claude Code

Cuando le pides a Claude Code que construya una integración de Firma, el código de backend generado debería verse así:

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

El endpoint `create-and-send` crea la Solicitud de Firma y la envía a los Destinatarios de forma atómica. Si necesitas revisar o modificar la solicitud antes de enviarla, usa `POST /signing-requests` para crear un borrador y luego `POST /signing-requests/{id}/send` por separado.

<Warning>
  Nunca expongas tu Clave API en código de frontend. Llama siempre a la API de Firma desde un backend donde los secretos se mantengan seguros.
</Warning>

## Integración de webhooks

Para hacer seguimiento de los eventos de firma en tiempo real, pídele a Claude Code que añada un manejador de webhooks:

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

El agente generará algo como esto:

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

En el panel de Firma, en **Configuración > Webhooks**, registra la URL de tu endpoint. Firma envía eventos para todos los cambios de estado principales. Consulta la [guía de webhooks](/es/guides/webhooks) para ver la lista completa de eventos y la verificación de firmas.

<Warning>
  Verifica siempre la firma del webhook usando tu secreto de firma de webhook de Firma en producción. Consulta la [guía de webhooks](/es/guides/webhooks) para más detalles de implementación.
</Warning>

## Firma incrustada

Para apps donde los Firmantes completan documentos dentro de tu interfaz en lugar de abrir una página alojada por Firma, la respuesta de `create-and-send` incluye `first_signer.id` (el `signing_request_user_id`) y un `first_signer.signing_link` ya listo para usar. Carga la URL del Firmante en un 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>
```

Consulta la [guía de firma incrustada](/es/guides/embeddable-signing) para ver la configuración completa, incluidas las mejores prácticas de seguridad.

## Consejos

* **Usa `firma-docs` para construir, `firma-api` para operar.** El servidor de documentación ayuda a Claude Code a escribir código de integración correcto. El servidor de la API le permite gestionar Solicitudes de Firma, Plantillas y Espacios de Trabajo directamente.
* **Pasa `template_id` explícitamente.** Las Plantillas son la forma más segura de limitar lo que el agente puede enviar.
* **Valida antes de enviar.** Para documentos de mayor riesgo, pídele a Claude Code que cree un borrador con `POST /signing-requests` y que confirme antes de llamar a `POST /signing-requests/{id}/send`.
* **Espacios de Trabajo para apps multiinquilino.** Si estás construyendo un producto SaaS, dale a cada cliente final su propio Espacio de Trabajo de Firma para que las Plantillas y el uso se mantengan aislados.

## Próximos pasos

* [Autenticación de la API](/es/guides/authentication) - Claves API y alcance por Espacio de Trabajo
* [Guía de webhooks](/es/guides/webhooks) - Tipos de eventos, payloads y verificación de firmas
* [Firma incrustada](/es/guides/embeddable-signing) - Experiencia de firma dentro de la app
* [Creación de Espacios de Trabajo](/es/guides/creating-workspaces) - Configuraciones multiinquilino para apps SaaS
* [Integración MCP](/es/guides/mcp) - Referencia completa del servidor MCP con las 84 herramientas
* [Guía de configuración completa](/es/guides/complete-setup-guide) - Recorrido completo de integración de Firma
* [Referencia de la API](/api-reference) - Documentación completa de endpoints