Tutorial de inicio rápido

El acceso a la API requiere aprobación

Para usar la API de Legalesign necesitas contactarnos para que se apruebe el uso de la API para tu cuenta.

sugerencia

¿Usando Cursor, Claude u otra herramienta de codificación AI? Conéctala con la documentación de Legalesign para obtener ayuda contextual mientras sigues este tutorial.

En este tutorial completarás las llamadas clave a la API que la mayoría de los desarrolladores necesitan en una integración de firma electrónica: subir un documento y enviarlo para firma.

La API de Legalesign es escalable, versátil y ha sido probada en producción en los sistemas de nuestros clientes durante muchos años. Puedes usarla para un documento simple con un único firmante, o enviar documentos para testigos o aprobaciones, optimizada para lotes, con formularios y más. Puedes integrarla para un solo propósito o incrustarla en tu software para tus clientes - ver integraciones.

La API REST realiza la mayoría de las funciones y es la forma más sencilla para comenzar. Si necesitas más, consulta la interfaz GraphQL. Legalesign es API primero con GraphQL. Puedes usar cualquiera, según prefieras.

Seguiremos estos pasos:

Crear una cuenta + clave API (ver Obtener verificación para acceso API).
Confirmar que las credenciales funcionan y obtener tu ID de equipo.
Subir un documento a través de la aplicación web.
Enviar ese documento para firmar vía API.
Descargarlo después de firmado.
Subir un documento vía API.

La API REST de Legalesign es fácil de usar. La referencia técnica incluye un editor de código. Puedes hacer solicitudes directamente desde la referencia técnica con tu clave API, pero si no, solo copia y pega directamente en tu código.

Imagen del Generador de Código
Figura 1: El editor de código de la API REST.

Bibliotecas cliente

O para la interfaz GraphQL Node.js

sugerencia

Recomendamos que los desarrolladores trabajen directamente con la API en lugar de los SDK. Para ayudar, hay un generador de código de copiar y pegar en la especificación técnica, y tu IA puede producir ejemplos rápidamente usando la especificación OpenAPI. ¿Por qué? La API fuente tiene más funcionalidades que los SDK, de todas formas querrás conocer los endpoints que usas, evitarás sobrecarga de abstracción y dependencias, y—basado en nuestra experiencia—también lo harás más rápido.

1. Crear una cuenta

Ve a registro en legalesign. Usa un correo normal para crear la cuenta (no uses Google), las identidades federadas como Google no funcionarán para la API.

Se te pedirá crear un equipo. Los equipos son la base de Legalesign. Todo el procesamiento de documentos ocurre en un equipo. Necesitas referenciar tu equipo en la mayoría de las llamadas API.

info

Un 'equipo' o un 'grupo' son lo mismo. En la aplicación web hablamos de 'equipos', pero en el esquema API es un grupo.

Contacta soporte para obtener una clave API. Cuéntanos tu caso de uso, experiencia en desarrollo API y algunos detalles para confirmar que eres real (p.ej. detalles de dónde trabajas).

Configuraciones API

Una vez verificado, ve al Panel API. Genera tus credenciales API en la sección Clave API.

Tómate un momento para revisar el Portal de Desarrollo.

Sandbox

En la sección Ambiente, una alerta muestra si estás en modo sandbox o producción.

Sandbox limita dónde puedes enviar tus documentos. Verás un formulario para añadir hasta 5 correos aprobados, añade algunos ahora.

Cuando tu integración esté lista: pasa a modo producción.

sugerencia

Crea un segundo equipo. Usa tu primer equipo para desarrollo y otros para producción. Informa a soporte del nombre de tu equipo de desarrollo para excluirlo de facturación.

Clave API

En la sección Clave API verás los detalles de tus claves API. Solo se muestra la clave en sí cuando creas una.

La sección Inicio rápido contiene ejemplos de copiar y pegar para probar tu clave.

Captura sección Clave API

Webhooks y Registros

Añade webhooks (tus escuchas para eventos Legalesign) y revisa tus registros.

Captura sección Webhooks

2. Una solicitud GET exitosa

La URL raíz siempre es: https://eu-api.legalesign.com/

Comienza con una solicitud GET para confirmar que tus credenciales funcionan. Reemplaza los valores de usuario y secreto en el código abajo.

Curl se usa en los ejemplos, y puedes cambiar entre cURL, Node.js, Python, C# y Go usando las pestañas abajo.

cURL
Node.js
Python
C#
Go

curl -H "Authorization: ApiKey username:secret" -H "Content-Type: application/json" -X GET https://eu-api.legalesign.com/api/v1/group/

import fetch from 'node-fetch';

async function getGroups() {
  const response = await fetch('https://eu-api.legalesign.com/api/v1/group/', {
    method: 'GET',
    headers: {
      'Authorization': 'ApiKey username:secret',
      'Content-Type': 'application/json',
    },
  });

  if (!response.ok) {
    throw new Error(`Request failed with status ${response.status}`);
  }

  const data = await response.json();
  console.log(data);
}

getGroups().catch((error) => {
  console.error(error);
  process.exit(1);
});

import requests

headers = {
    "Authorization": "ApiKey username:secret",
    "Content-Type": "application/json",
}

response = requests.get(
    "https://eu-api.legalesign.com/api/v1/group/",
    headers=headers,
    timeout=30,
)
response.raise_for_status()

print(response.json())

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        using var client = new HttpClient();
        using var request = new HttpRequestMessage(
            HttpMethod.Get,
            "https://eu-api.legalesign.com/api/v1/group/"
        );

        request.Headers.TryAddWithoutValidation("Authorization", "ApiKey username:secret");
        request.Headers.TryAddWithoutValidation("Content-Type", "application/json");

        using var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        var body = await response.Content.ReadAsStringAsync();
        Console.WriteLine(body);
    }
}

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://eu-api.legalesign.com/api/v1/group/", nil)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "ApiKey username:secret")
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		log.Fatalf("request failed: %s", resp.Status)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(body))
}

Documentación de la API: Referencia API GET group.

Cuando ejecutas la consulta anterior, verás tus grupos devueltos en JSON. Éxito. 👏

Los datos de la respuesta contienen la 'URI de recurso' para tu grupo y se ve como /api/v1/group/:groupId/. Toma nota de esto, lo necesitarás para la mayoría de llamadas API.

sugerencia

Una URI de recurso siempre tendrá el mismo formato. Para un PDF sería '/api/v1/templatepdf/:pdfId/', para un documento enviado será '/api/v1/document/:documentId/'. Nota que todas las URIs terminan con una barra '/', igual que las URLs para tus llamadas API, siempre termina con barra.

Si la solicitud GET falló, verifica que:

tu ApiKey esté formateada correctamente (comienza con 'ApiKey'),
tengas un header Content-Type para application/json, y
tu url termine con una barra.

Consulta también solución de problemas.

3. Subir un documento vía la aplicación web

Para comenzar, subiremos un documento a través de la aplicación web y lo enviaremos mediante la API. Cubriremos cómo subir un documento vía API más adelante.

Ve a la aplicación web y sube tu documento. Agrega un rol de firmante único y arrastra un campo de firma. La página del editor indicará si el documento es 'válido' (un ejemplo de 'inválido' sería si agregas un rol de firmante sin un campo de firma relacionado).

En el editor de formularios, copia el largo ID alfanumérico de la URL, decodifícalo en base64 y descarta las primeras 3 letras (que deberían ser 'tpl'). El resto es un UUID que es tu ID.

En lenguaje REST API, la URI de recurso para este documento es /api/v1/templatepdf/UUID/.

Aprende más acerca de los IDs web y API.

Nuestra nomenclatura es que un documento subido es una 'plantilla' y cuando lo envías creas un 'documento'.

sugerencia

Si deseas archivar una plantilla al enviar el documento, configura 'archive_upon_send' como atributo en la solicitud de subida. Si quieres que la plantilla nunca aparezca y se elimine luego de enviar, ponle el título '[deleted]' - nuestros sistemas de limpieza lo detectarán y lo eliminarán en uno o dos días. También puedes establecer tiempos de retención cortos a nivel de grupo - aprende más.

4. Enviar un documento para firma

Ahora enviaremos esto a través de la API. Recuerda usar un correo en tus emails 'aprobados' en sandbox. Usa las pestañas abajo para obtener la solicitud en tu lenguaje preferido.

cURL
Node.js
Python
C#
Go

curl -H "Authorization: ApiKey [username]:[secret]" -H "Content-Type: application/json" -X POST --data '{ "group": "/api/v1/group/[:groupId]/", "name": "Name of doc", "templatepdf": "/api/v1/templatepdf/UUID/", "signers": [{"firstname": "Joe", "lastname": "Bloggs", "email": "[your@email.com]", "order": 0 }], "do_email": true }' https://eu-api.legalesign.com/api/v1/document/

import fetch from 'node-fetch';

const payload = {
  group: '/api/v1/group/[:groupId]/',
  name: 'Name of doc',
  templatepdf: '/api/v1/templatepdf/UUID/',
  signers: [
    {
      firstname: 'Joe',
      lastname: 'Bloggs',
      email: '[your@email.com]',
      order: 0,
    },
  ],
  do_email: true,
};

async function sendDocument() {
  const response = await fetch('https://eu-api.legalesign.com/api/v1/document/', {
    method: 'POST',
    headers: {
      'Authorization': 'ApiKey [username]:[secret]',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(payload),
  });

  if (response.status !== 201) {
    const errorBody = await response.text();
    throw new Error(`Request failed with status ${response.status}: ${errorBody}`);
  }

  console.log('Document sent successfully');
  const location = response.headers.get('location');
  if (location) {
    console.log(`Location: ${location}`);
  }
}

sendDocument().catch((error) => {
  console.error(error);
  process.exit(1);
});

import requests

payload = {
    "group": "/api/v1/group/[:groupId]/",
    "name": "Name of doc",
    "templatepdf": "/api/v1/templatepdf/UUID/",
    "signers": [
        {
            "firstname": "Joe",
            "lastname": "Bloggs",
            "email": "[your@email.com]",
            "order": 0,
        }
    ],
    "do_email": true,
}

headers = {
    "Authorization": "ApiKey [username]:[secret]",
    "Content-Type": "application/json",
}

response = requests.post(
    "https://eu-api.legalesign.com/api/v1/document/",
    json=payload,
    headers=headers,
    timeout=30,
)
response.raise_for_status()

print("Document sent successfully")
print("Location:", response.headers.get("Location"))

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        var payload = new
        {
            group = "/api/v1/group/[:groupId]/",
            name = "Name of doc",
            templatepdf = "/api/v1/templatepdf/UUID/",
            signers = new[]
            {
                new
                {
                    firstname = "Joe",
                    lastname = "Bloggs",
                    email = "[your@email.com]",
                    order = 0,
                },
            },
            do_email = true,
        };

        using var client = new HttpClient();
        using var request = new HttpRequestMessage(
            HttpMethod.Post,
            "https://eu-api.legalesign.com/api/v1/document/"
        );
        request.Headers.TryAddWithoutValidation("Authorization", "ApiKey [username]:[secret]");

        var json = JsonSerializer.Serialize(payload);
        request.Content = new StringContent(json, Encoding.UTF8, "application/json");

        using var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        Console.WriteLine("Document sent successfully");
        if (response.Headers.Location is not null)
        {
            Console.WriteLine($"Location: {response.Headers.Location}");
        }
    }
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

func main() {
	payload := map[string]any{
		"group": "/api/v1/group/[:groupId]/",
		"name":  "Name of doc",
		"templatepdf": "/api/v1/templatepdf/UUID/",
		"signers": []map[string]any{
			{
				"firstname": "Joe",
				"lastname":  "Bloggs",
				"email":     "[your@email.com]",
				"order":     0,
			},
		},
		"do_email": true,
	}

	body, err := json.Marshal(payload)
	if err != nil {
		log.Fatal(err)
	}

	req, err := http.NewRequest(
		http.MethodPost,
		"https://eu-api.legalesign.com/api/v1/document/",
		bytes.NewReader(body),
	)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "ApiKey [username]:[secret]")
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusCreated {
		log.Fatalf("unexpected status: %s", resp.Status)
	}

	fmt.Println("Document sent successfully")
	fmt.Println("Location:", resp.Header.Get("Location"))
}

Actualiza todos los corchetes cuadrados. Referencia API para enviar un documento.

sugerencia

Cuando visites la documentación de referencia para enviar un documento examina bien todos los atributos posibles. Verás muchos que ayudan con las particularidades de una integración: etiquetas para tus propias referencias e IDs (que te retornan en webhooks), un redireccionamiento para firmantes, texto personalizado en el pdf, y más.

Una llamada exitosa retornará código de estado 201. ✨

Obtener el nuevo ID del documento enviado

La parte importante de la respuesta es la cabecera location. Esta contiene el nuevo ID de documento.

sugerencia

Usa atributos de 'tag' del documento y añade tus propias referencias para facilitar la vinculación con tu base de datos.

La cabecera location se verá como /api/v1/status/:documentId/.

La URI 'status' retorna un conjunto breve (y rápido de consultar) de atributos del documento.

Para solicitar todo acerca de un documento usa /api/v1/document/:documentId/.

info

Si una solicitud no es exitosa, el CUERPO de la respuesta generalmente contiene información de error. Si no obtienes un estado de éxito, revisa el CUERPO para texto explicativo. Consulta también solución de problemas.

Aprende más sobre la llamada API Enviar Documento.

5. Descargar el documento firmado

Con el ID de documento enviado que recibiste arriba, realiza una solicitud de descarga PDF en el lenguaje de tu elección:

cURL
Node.js
Python
C#
Go

curl -H "Authorization: ApiKey [username]:[secret]" -o download.pdf -X GET https://eu-api.legalesign.com/api/v1/pdf/:documentId/

import { writeFile } from 'node:fs/promises';
import fetch from 'node-fetch';

async function downloadPdf() {
  const response = await fetch('https://eu-api.legalesign.com/api/v1/pdf/:documentId/', {
    method: 'GET',
    headers: {
      'Authorization': 'ApiKey [username]:[secret]',
    },
  });

  if (!response.ok) {
    throw new Error(`Request failed with status ${response.status}`);
  }

  const buffer = await response.arrayBuffer();
  await writeFile('download.pdf', Buffer.from(buffer));
  console.log('Saved download.pdf');
}

downloadPdf().catch((error) => {
  console.error(error);
  process.exit(1);
});

import requests

headers = {"Authorization": "ApiKey [username]:[secret]"}

response = requests.get(
    "https://eu-api.legalesign.com/api/v1/pdf/:documentId/",
    headers=headers,
    stream=True,
    timeout=30,
)
response.raise_for_status()

with open("download.pdf", "wb") as file:
    for chunk in response.iter_content(chunk_size=8192):
        file.write(chunk)

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        using var client = new HttpClient();
        using var request = new HttpRequestMessage(
            HttpMethod.Get,
            "https://eu-api.legalesign.com/api/v1/pdf/:documentId/"
        );
        request.Headers.TryAddWithoutValidation("Authorization", "ApiKey [username]:[secret]");

        using var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        var bytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("download.pdf", bytes);
        Console.WriteLine("Saved download.pdf");
    }
}

package main

import (
	"io"
	"log"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(
		http.MethodGet,
		"https://eu-api.legalesign.com/api/v1/pdf/:documentId/",
		nil,
	)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "ApiKey [username]:[secret]")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		log.Fatalf("request failed: %s", resp.Status)
	}

	file, err := os.Create("download.pdf")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	if _, err := io.Copy(file, resp.Body); err != nil {
		log.Fatal(err)
	}

	log.Println("Saved download.pdf")
}

Referencia API de descarga PDF.

El binario PDF está en el cuerpo de la respuesta. El comando curl '-o' pone el CUERPO de la respuesta directamente en un archivo.

Muchas librerías REST o HTTP tratan los objetos de respuesta HTTP como archivos, en ese caso simplemente guarda tu objeto de respuesta como un archivo normal.

sugerencia

Usa webhooks para ser notificado de un evento de firma y luego descarga el documento. Ver webhooks.

6. Subir un PDF

Haz clic aquí para descargar un PDF con etiquetas de texto de ejemplo, más información sobre campos de formulario PDF a continuación.

Para esta llamada, convierte tu PDF en una cadena codificada en base64. Esto no se hace correctamente dentro del generador de código de la documentación. En su lugar, copia este seudocódigo y tu IA amigable lo convertirá a tu lenguaje preferido:

$data = (
  'group': '/api/v1/group/:groupId/',
  'title': 'title of pdf',
  'pdf_file': base64encode(open('/path/to/file','rb')),
  'process_tags': true
)
$headers = (
  'Authorization': 'ApiKey username:secret',
  'Content-Type': 'application/json'
)
response = httplibrary.post('https://eu-api.legalesign.com/api/v1/templatepdf/', jsonEncode($data), $headers)
assert response.status == 201

pdfId = response.headers['location']

Referencia API de subida PDF.

Como siempre, una respuesta exitosa POST devolverá estatus '201' y el nuevo ID estará en la cabecera 'location' de la respuesta.

assert response.status == 201
pdfId = response.headers['location']

La URI del recurso pdf se verá como /api/v1/templatepdf/:pdfId/.

Enviar el nuevo PDF

Vuelve al código que usaste para enviar tu primer documento y reemplaza el valor templatepdf.

Emite la solicitud nuevamente y listo, enviaste tu PDF para firmar.

Antes de comenzar a codificar, sin embargo, sigue leyendo para aprender más sobre los campos PDF.

¿Y qué hay de los campos PDF?

¿Cómo sabe Legalesign dónde debe firmar la persona en el PDF, o qué secciones cambiar al enviar? La respuesta es que nuestro PDF estaba pre-preparado con etiquetas: ponemos una etiqueta de texto Legalesign dentro del PDF y configuramos 'process_tags' a true en la solicitud de subida PDF.

Descarga un PDF de texto etiquetado de ejemplo.

Las etiquetas de texto son texto especialmente formateado para poner en un PDF. Legalesign analizará el texto en tu archivo, reemplazando las etiquetas con campos de firma y campos de formulario. Para un solo firmante solo necesitas añadir: <<t=signature>>. Legalesign lo identificará y colocará la firma ahí. Aprende sobre etiquetas de texto.

Las etiquetas de texto tienen curva de aprendizaje y requieren ensayo y error. Otros métodos están indicados abajo, pero obtienes toda la capacidad del sistema de formularios Legalesign con esto. Usa la aplicación web para probar etiquetas. Contacta soporte para asistencia y ejemplos.

Aquí hay 4 otras formas de configurar campos:

1. La versión más fácil/rápida. Configura tu PDF usando la aplicación web Legalesign.

Después de subir un PDF irás a la interfaz del editor donde puedes arrastrar y soltar campos de formulario.

Arrastra y suelta una firma, luego toma nota del ID codificado en la dirección web. Esto se verá como algo tipo 'dHBsMTRlZTQ0ZWUtZGE0Ni0xMWVmLTllZmUtMDI5ZGQ0ODkzZGRk'.

Decodifica en base64 este ID y verás que es un UUID prefijado con 'tpl'. La parte UUID (elimina 'tpl') es tu pdfID. Aprende más sobre IDs en Legalesign.

Tu URI recurso API PDF será - /api/v1/templatepdf/:pdfId/.

Pon eso en el atributo 'templatepdf' de la llamada enviar documento.

info

Si planeas enviar este PDF más de una vez, asegúrate que 'Auto archive' esté desactivado. Ver cómo

2. Usa coordenadas x/y para campos.

La forma más simple de empezar con coordenadas x/y es configurar un PDF en la app web y luego hacer una consulta API para esos campos (GET Campos PDF - /api/v1/templatepdf/:pdfId/fields/).

El objeto JSON que obtienes es el mismo esquema JSON que necesitas para crear campos también.

Úsalo como plantilla. Modifica cualquier valor y realiza POST al mismo endpoint (ajustando el ID PDF según corresponda). Endpoint Crear Campo PDF.

3. Incrusta nuestra página de edición PDF. ¡NUEVO!

Usa nuestro componente editor para incrustar nuestro editor PDF directamente en tu propia aplicación. Aprende más sobre el componente editor de documentos.

4. Campos de Formulario PDF ¡NUEVO!

Si tu PDF contiene campos normales de formulario PDF, Legalesign puede importarlos automáticamente.

¡Feliz codificación!

En este tutorial obtuviste credenciales API, consultaste exitosamente tus grupos, enviaste un documento para firmar usando HTML y PDF, y descargaste un documento firmado.

¡Feliz codificación! Estamos aquí para ayudarte, contacta soporte para cualquier asistencia.

sugerencia

Genial, llegaste al final - gracias por leer esto. Nuestra última petición, y consejo, basado en años de experiencia de desarrolladores que integran con esta API, es que tomes un momento para leer todos los atributos en el endpoint crear documento (y también haz clic para ver qué contienen 'signers', 'pdftext' y 'signertext')—es la llamada más importante en tu integración. Crear un documento para firmar.

Tutorial de inicio rápido

Bibliotecas cliente

1. Crear una cuenta

Configuraciones API

Sandbox

Clave API

Webhooks y Registros

2. Una solicitud GET exitosa

3. Subir un documento vía la aplicación web

4. Enviar un documento para firma

Obtener el nuevo ID del documento enviado

5. Descargar el documento firmado

6. Subir un PDF

Enviar el nuevo PDF

¿Y qué hay de los campos PDF?

1. La versión más fácil/rápida. Configura tu PDF usando la aplicación web Legalesign.

2. Usa coordenadas x/y para campos.

3. Incrusta nuestra página de edición PDF. ¡NUEVO!

4. Campos de Formulario PDF ¡NUEVO!

¡Feliz codificación!

Próximos pasos:

Export This Article

Bibliotecas cliente​

1. Crear una cuenta​

Configuraciones API​

Sandbox​

Clave API​

Webhooks y Registros​

2. Una solicitud GET exitosa​

3. Subir un documento vía la aplicación web​

4. Enviar un documento para firma​

Obtener el nuevo ID del documento enviado​

5. Descargar el documento firmado​

6. Subir un PDF​

Enviar el nuevo PDF​

¿Y qué hay de los campos PDF?​

1. La versión más fácil/rápida. Configura tu PDF usando la aplicación web Legalesign.​

2. Usa coordenadas x/y para campos.​

3. Incrusta nuestra página de edición PDF. ¡NUEVO!​

4. Campos de Formulario PDF ¡NUEVO!​

¡Feliz codificación!​

Próximos pasos:​

Export This Article

Bibliotecas cliente

1. Crear una cuenta

Configuraciones API

Sandbox

Clave API

Webhooks y Registros

2. Una solicitud GET exitosa

3. Subir un documento vía la aplicación web

4. Enviar un documento para firma

Obtener el nuevo ID del documento enviado

5. Descargar el documento firmado

6. Subir un PDF

Enviar el nuevo PDF

¿Y qué hay de los campos PDF?

1. La versión más fácil/rápida. Configura tu PDF usando la aplicación web Legalesign.

2. Usa coordenadas x/y para campos.

3. Incrusta nuestra página de edición PDF. ¡NUEVO!

4. Campos de Formulario PDF ¡NUEVO!

¡Feliz codificación!

Próximos pasos: