Inserta las firmas electrónicas
en tu flujo de trabajo.

Prueba gratuita
Implementación rápida
Potente y segura

Configura airSlate SignNow para que se adapte a las necesidades de tu empresa

¿Quieres mejorar los flujos de trabajo de los documentos de tu empresa? Mejora la experiencia del usuario en tu sitio web o aplicación móvil con la potente API de firma electrónica de airSlate SignNow. Crea tu cuenta sandbox hoy mismo y prueba nuestra API de forma gratuita.

Solución de firma electrónica personalizable

Personaliza los flujos de trabajo de firma electrónica con la marca de tu empresa.

Precios competitivos y escalables

Nuestros planes de precios se adaptan a las necesidades de tu negocio.

Configuración rápida

La documentación detallada y los ejemplos de codificación claros garantizan una experiencia de desarrollador excelente.

Alto índice de éxito

Rendimiento superior de la aplicación garantizado con nuestro monitoreo de la API las 24 horas, todos los días.

Funcionalidad flexible para cualquier caso de uso e industria

La API de airSlate SignNow permite que los usuarios finalicen ciclos completos de aprobación de documentos. Firma y envía documentos para firmar, solicita pagos, crea y completa plantillas reutilizables, y rastrea el estado de los documentos.

Sube un PDF con campos rellenables Añade campos a los documentos para crear PDFs rellenables

Envía un documento para firmar Invita a otros a rellenar y firmar formularios por correo electrónico

Verifica el estado de un documento Recibe notificaciones una vez que el documento se haya completado

Descarga documentos firmados Aprovecha las ventajas de la eficiente API de firma electrónica

cURL

Copy code

curl -X PUT \
    'https://api.signnow.com/document/{{document_id}}' \
    -H 'Authorization: Bearer {{bearer_token}}' \
    -H 'Content-Type: application/json' \
    -d '{
      "fields": [
        {
          "x": 305,
          "y": 18,
          "width": 122,
          "height": 10,
          "page_number": 0,
          "label": "first_name",
          "role": "Signer",
          "required": true,
          "type": "text",
          "prefilled_text": "John"
        },
        {
          "x": 305,
          "y": 38,
          "width": 122,
          "height": 10,
          "page_number": 0,
          "label": "last_name",
          "role": "Signer",
          "required": true,
          "type": "text",
          "prefilled_text": "Doe"
        },
        {
          "x":305,
          "y":67,
          "width":100,
          "height":34,
          "page_number":0,
          "label":"a sample label",
          "role":"Signer",
          "required":true,
          "type":"signature"
        }
      ]
    }'

 curl -X PUT \
    'https://api.signnow.com/document/{{document_id}}' \
    -H 'Authorization: Bearer {{bearer_token}}' \
    -H 'Content-Type: application/json' \
    -d '{
      "fields": [
        {
          "x": 305,
          "y": 18,
          "width": 122,
          "height": 10,
          "page_number": 0,
          "label": "first_name",
          "role": "Signer",
          "required": true,
          "type": "text",
          "prefilled_text": "John"
        },
        {
          "x": 305,
          "y": 38,
          "width": 122,
          "height": 10,
          "page_number": 0,
          "label": "last_name",
          "role": "Signer",
          "required": true,
          "type": "text",
          "prefilled_text": "Doe"
        },
        {
          "x":305,
          "y":67,
          "width":100,
          "height":34,
          "page_number":0,
          "label":"a sample label",
          "role":"Signer",
          "required":true,
          "type":"signature"
        }
      ]
    }'

 curl -X POST \
    'https://api.signnow.com/document/{{document_id}}/invite' \
    -H 'Authorization: Bearer {{bearer_token}}' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -d '{
      "document_id": "{{document_id}}",
      "to": [
        {
          "email": "{{email1}}",
          "role_id": "{{role_id_1}}",
          "role": "{{role_1}}",
        },
        {
          "email": "{{email2}}",
          "role_id": "{{role_id_2}}",
          "role": "{{role_2}}",
        }
      ],
      "from": "{{email_from}}",
      "subject": "email_subject",
      "message": "email_message"
    }'

 curl -X GET \
    'https://api.signnow.com/document/{{document_id}}' \
    -H 'Authorization: Bearer {{bearer_token}}' \
    -H 'Content-Type: application/json' \

 curl -X GET \
    'https://api.signnow.com/document/{{document_id}}/download?type=collapsed' \
    -H 'Authorization: Bearer {{bearer_token}}' \

api.document.fieldextract({
  token: 'your auth token',
  filepath: 'path to file',
}, (err, res) => {
  // handle error or process response data
});

const fieldInvite = {
  from: 'EMAIL_OF_SENDER',
  to: [
    {
      email: 'EMAIL_OF_SIGNER',
      role: 'Signer 1',
      order: 1,
      reassign: '0',
      decline_by_signature: '0',
      reminder: 4,
      expiration_days: 27,
      subject: 'Field invite Signer1',
      message: 'Message',
    },
  ],
};

api.document.invite({
  data: {
    ...fieldInvite,
  },
  id: 'DOCUMENT_ID_GOES_HERE',
  token: 'YOUR_AUTH_TOKEN',
}, (err, res) => {
  // handle error or process response data
});

api.document.view({
  token: 'your auth token',
  id: 'document id',
}, (err, res) => {
  // handle error or process response data
});

api.document.download({
  token: 'your auth token',
  id: 'document id',
  options: { 
    withAttachments: true, // false by default
    withHistory: true, // false by default
  },
}, (err, res) => {
  // handle error or process response data
});

public static partial class DocumentExamples
    {
        /// 
        /// Uploads a PDF with fillable field (Signature field)
        /// 
        /// Full qualified path to your PDF with field tags.
        /// Access token
        public static async Task UploadDocumentWithFieldExtract(string pdfFilePath, Token token)
        {
            var signNowContext = new SignNowContext(token);
 
            await using var fileStream = File.OpenRead(pdfFilePath);
            // Upload the document with field extract
            var uploadResponse = signNowContext.Documents
                .UploadDocumentWithFieldExtractAsync(fileStream, "DocumentSampleWithSignatureTextTag.pdf").Result;    
 
            var documentId = uploadResponse.Id;
 
            return await signNowContext.Documents.GetDocumentAsync(documentId);
        }
    }

public static partial class InviteExamples
    {
        /// <summary>
        /// Create a role-based invite to the document for signature.
        /// </summary>
        /// <param name document"">airSlate SignNow document with fields you’d like to have signed
        /// <param name email"">The email of the invitee.
        /// <param name token"">Access token
        /// <returns><see cref InviteResponse""></see> without any Identity of invite request.</returns>
        public static async Task<InviteResponse> CreateRoleBasedInviteToSignTheDocument(SignNowDocument document, string email, Token token)      
        {
            // using token from the Authorization step
            var signNowContext = new SignNowContext(token);
 
            // Create role-based invite
            var invite = new RoleBasedInvite(document)
            {
                Message = $"{email} invited you to sign the document {document.Name}",
                Subject = "The subject of the Email"
            };
 
            // Creates options for signers
            var signer = new SignerOptions(email, invite.DocumentRoles().First())
                {
                    ExpirationDays = 15,
                    RemindAfterDays = 7,
                }
                .SetAuthenticationByPassword("***PASSWORD_TO_OPEN_THE_DOCUMENT***");
 
            // Attach signer to existing roles in the document
            invite.AddRoleBasedInvite(signer);
 
            // Creating Invite request
            return await signNowContext.Invites
                .CreateInviteAsync(document.Id, invite)
                .ConfigureAwait(false);
        }
    }</InviteResponse>

public static partial class InviteExamples
    {
        /// 
        /// Create a role-based invite to the document for signature.
        /// 
        /// airSlate SignNow document with fields you’d like to have signed
        /// The email of the invitee.
        /// Access token
        ///  without any Identity of invite request.
        public static async Task CreateRoleBasedInviteToSignTheDocument(SignNowDocument document, string email, Token token)      
        {
            // using token from the Authorization step
            var signNowContext = new SignNowContext(token);
 
            // Create role-based invite
            var invite = new RoleBasedInvite(document)
            {
                Message = $"{email} invited you to sign the document {document.Name}",
                Subject = "The subject of the Email"
            };
 
            // Creates options for signers
            var signer = new SignerOptions(email, invite.DocumentRoles().First())
                {
                    ExpirationDays = 15,
                    RemindAfterDays = 7,
                }
                .SetAuthenticationByPassword("***PASSWORD_TO_OPEN_THE_DOCUMENT***");
 
            // Attach signer to existing roles in the document
            invite.AddRoleBasedInvite(signer);
 
            // Creating Invite request
            return await signNowContext.Invites
                .CreateInviteAsync(document.Id, invite)
                .ConfigureAwait(false);
        }
    }

public static partial class DocumentExamples
    {
        /// <summary>
        /// Check the Status of the Document
        /// <para>Can be one of:</para>
        /// <list type bullet"">
        /// <item><description><see cref DocumentStatus.NoInvite""></see></description></item>
        /// <item><description><see cref DocumentStatus.Pending""></see></description></item>
        /// <item><description><see cref DocumentStatus.Completed""></see></description></item>
        /// </list>
        /// </summary>
        /// <param name documentId"">Identity of the document
        /// <param name token"">Access token
        /// <returns><see cref DocumentStatus""></see></returns>
        public static async Task<DocumentStatus> CheckTheStatusOfTheDocument(string documentId, Token token)    
        {
            // using token from the Authorization step
            var signNowContext = new SignNowContext(token);
 
            var document = await signNowContext.Documents
                .GetDocumentAsync(documentId).ConfigureAwait(false);
 
            return document.Status;
        }
    }</DocumentStatus>

public static partial class DocumentExamples
    {
        /// 
        /// Check the Status of the Document
        /// Can be one of:
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// Identity of the document
        /// Access token
        /// 
        public static async Task CheckTheStatusOfTheDocument(string documentId, Token token)    
        {
            // using token from the Authorization step
            var signNowContext = new SignNowContext(token);
 
            var document = await signNowContext.Documents
                .GetDocumentAsync(documentId).ConfigureAwait(false);
 
            return document.Status;
        }
    }

public static partial class DocumentExamples
    {
        /// 
        /// Downloads signed document
        /// 
        /// ID of signed document
        /// Access token
        public static async Task DownloadSignedDocument(string documentId, Token token)    
        {
            var signNowContext = new SignNowContext(token);
 
            return await signNowContext.Documents
                .DownloadDocumentAsync(documentId, DownloadType.PdfCollapsed)
                .ConfigureAwait(false);
        }
    }

public String uploadDocumentWithTags(@RequestParam("file") MultipartFile file,
                                       Model model,
                                       RedirectAttributes redirectAttributes
  ) {
      try {
          if (isUserNotAuthorized()) {
              return getLoginRedirectPage(redirectAttributes, "/examples/uploadDocumentWithTags");    
          }
          //upload document with tags to parse
          String documentId = provider.get().getSnClient()
                  .documentsService()
                  .uploadDocumentWithTags(file.getInputStream(), file.getOriginalFilename());
          updateDocumentList();
          model.addAttribute("message", "fileId: " + documentId);
      } catch (IOException | SNException e) {
          model.addAttribute("message", String.format("Couldn't upload document %s because %s %s"    
                  , file.getOriginalFilename(), e.getMessage(), e.getCause())
          );
      }
      return "add_text_tag_on_document";
  }

 public String uploadDocumentWithTags(@RequestParam("file") MultipartFile file,
                                       Model model,
                                       RedirectAttributes redirectAttributes
  ) {
      try {
          if (isUserNotAuthorized()) {
              return getLoginRedirectPage(redirectAttributes, "/examples/uploadDocumentWithTags");    
          }
          //upload document with tags to parse
          String documentId = provider.get().getSnClient()
                  .documentsService()
                  .uploadDocumentWithTags(file.getInputStream(), file.getOriginalFilename());
          updateDocumentList();
          model.addAttribute("message", "fileId: " + documentId);
      } catch (IOException | SNException e) {
          model.addAttribute("message", String.format("Couldn't upload document %s because %s %s"    
                  , file.getOriginalFilename(), e.getMessage(), e.getCause())
          );
      }
      return "add_text_tag_on_document";
  }

public String simpleFromInvite(@ModelAttribute SimpleFromInvite simpleFromInvite, Model model, RedirectAttributes redirectAttributes) {     
        if (isUserNotAuthorized()) {
            return getLoginRedirectPage(redirectAttributes, "/examples/simpleFromInvite");
        }
 
        final String fromEmail = simpleFromInvite.getFrom();
        final String toEmail = simpleFromInvite.getTo();
        final String documentId = simpleFromInvite.getDocumentId();
 
        try {
            model.addAttribute("documentList", provider.get().getUserDocuments());
            //create request for invite
            Document.SigningInviteRequest request = new Document.SigningInviteRequest(
                    fromEmail,
                    toEmail
            );
            request.subject = simpleFromInvite.getSubject();
            request.message = simpleFromInvite.getMessage();
 
            //send request for invite
            provider.get().getSnClient()
                    .documentsService()
                    .sendDocumentSignInvite(documentId, request);
 
            model.addAttribute("message",
                    String.format("Invitation for sign document %s already sent to %s from %s",
                            documentId,
                            toEmail,
                            fromEmail
                    )
            );
        } catch (SNException e) {
            String message = String.format("Couldn't send invitation request from %s to %s for sign document %s. %s %s"
                    , fromEmail, toEmail, documentId, e.getMessage(), e.getCause());
            model.addAttribute("message", message);
        }
 
        return "simple_from_invite";
    }

public String simpleFromInvite(@ModelAttribute SimpleFromInvite simpleFromInvite, Model model, RedirectAttributes redirectAttributes) {     
        if (isUserNotAuthorized()) {
            return getLoginRedirectPage(redirectAttributes, "/examples/simpleFromInvite");
        }
 
        final String fromEmail = simpleFromInvite.getFrom();
        final String toEmail = simpleFromInvite.getTo();
        final String documentId = simpleFromInvite.getDocumentId();
 
        try {
            model.addAttribute("documentList", provider.get().getUserDocuments());
            //create request for invite
            Document.SigningInviteRequest request = new Document.SigningInviteRequest(
                    fromEmail,
                    toEmail
            );
            request.subject = simpleFromInvite.getSubject();
            request.message = simpleFromInvite.getMessage();
 
            //send request for invite
            provider.get().getSnClient()
                    .documentsService()
                    .sendDocumentSignInvite(documentId, request);
 
            model.addAttribute("message",
                    String.format("Invitation for sign document %s already sent to %s from %s",
                            documentId,
                            toEmail,
                            fromEmail
                    )
            );
        } catch (SNException e) {
            String message = String.format("Couldn't send invitation request from %s to %s for sign document %s. %s %s"
                    , fromEmail, toEmail, documentId, e.getMessage(), e.getCause());
            model.addAttribute("message", message);
        }
 
        return "simple_from_invite";
    }

try {
           return provider.get()
                   .getSnClient()
                   .documentsService()
                   .getDocuments()
                   .stream()
                   .map(doc -> new DocumentInfo(doc.id, doc.document_name))
                   .collect(Collectors.toSet());
       } catch (SNException e) {
           e.printStackTrace();
       }
       return new HashSet<>();
   }

try {
           return provider.get()
                   .getSnClient()
                   .documentsService()
                   .getDocuments()
                   .stream()
                   .map(doc -> new DocumentInfo(doc.id, doc.document_name))
                   .collect(Collectors.toSet());
       } catch (SNException e) {
           e.printStackTrace();
       }
       return new HashSet<>();
   }

if __name__ == '__main__':
    signnow_python_sdk.Config(client_id="CLIENT_ID",
                              client_secret="CLIENT_SECRET",
                              environment="production")
 
    # Enter your own credentials
    username = "USER_NAME"
    password = "USER_PASSWORD"
 
    # Create access_token for the user
    access_token = signnow_python_sdk.OAuth2.request_token(username, password, '*')
 
    # Upload a new document
    file_path = os.path.dirname(os.path.realpath(__file__)) + '/TestDocument.pdf'
    doc_id = signnow_python_sdk.Document.upload(access_token['access_token'], file_path, True)    
 
    # Get documentdata
    document_data = signnow_python_sdk.Document.get(access_token['access_token'], doc_id['id'])

if __name__ == '__main__':
    signnow_python_sdk.Config(client_id="CLIENT_ID",
                              client_secret="CLIENT_SECRET",
                              environment="production")
 
    # Enter your own credentials
    username = "USER_NAME"
    password = "USER_PASSWORD"
    document_id = "DOCUMENT_ID"
 
    # Create access_token for the user
    access_token = signnow_python_sdk.OAuth2.request_token(username, password, '*')
 
    to = [{
        "email": "testemail@pdffiller.com",
        "role_id": "",
        "role": "Signer 1",
        "order": 1
    }]
 
    invite_payload = {
        "to": to,
        "from": username
    }
 
    # Send document invite
    invite_response = signnow_python_sdk.Document.invite(access_token['access_token'], document_id, invite_payload)

if __name__ == '__main__':
    signnow_python_sdk.Config(client_id="CLIENT_ID",
                              client_secret="CLIENT_SECRET",
                              environment="production")
 
    # Enter your own credentials
    username = "USER_NAME"
    password = "USER_PASSWORD"
    document_id = "DOCUMENT_ID"
 
    # Create access_token for the user
    access_token = signnow_python_sdk.OAuth2.request_token(username, password, '*')
 
    # get document history
    document_history = signnow_python_sdk.Document.get_history(access_token['access_token'], document_id)

if __name__ == '__main__':
    signnow_python_sdk.Config(client_id="CLIENT_ID",
                              client_secret="CLIENT_SECRET",
                              environment="production")

    # Enter your own credentials
    username = "USER_NAME"
    password = "USER_PASSWORD"
    document_id = "DOCUMENT_ID"

    # Create access_token for the user
    access_token = signnow_python_sdk.OAuth2.request_token(username, password, '*')

    dir_path = './downloaded_documents'
    enclose_document_history = False
    file_name = "signed_document"

    # Download signed document
    signnow_python_sdk.Document.download(access_token['access_token'], document_id, file_name, dir_path,
        enclose_document_history)

Ver todas las funciones de API Ver referencia API completa

Funcionalidades de firma electrónica compatibles con la industria para tu aplicación

Optimiza los flujos de trabajo de documentos con la API de firma electrónica personalizable airSlate SignNow: administra fácilmente los documentos y recopila firmas electrónicas legalmente vinculantes en una sola interfaz.

Opiniones de los clientes sobre nuestra API de firma electrónica

El fundador de SportsForms integró la solución de firma electrónica airSlate SignNow con su plataforma de registro en línea para acelerar procesos y eliminar el uso de papel.

Leer la historia completa

El equipo de airSlate SignNow ha sido excepcional y atento, la API ha sido genial y estamos muy contentos de haber elegido an airSlate SignNow como empresa.

Leer la historia completa

airSlate SignNow ofrece un mejor precio y es exactamente la solución que necesitábamos. Con airSlate SignNow, logramos reducir nuestro proceso de matriculación en un día o dos, dependiendo del miembro.

Leer la historia completa

Selecciona un plan API para tu negocio

Integra las firmas electrónicas en tu software y consigue 250 invitaciones de firma legalmente vinculantes con tu prueba de API gratuita.

Consulta los precios de la API

Ingenieros de soluciones

Estamos aquí para ayudarte a configurar la API según tu flujo de trabajo.

Revisar la documentación de la API de airSlate SignNow

La documentación detallada de la API es una guía por todo el proceso de desarrollo y proporciona ejemplos claros de codificación.

Videoguías

Consulta las instrucciones para construir integraciones personalizadas con facilidad.

Comienza con cualquiera de nuestros SDK

Obtén SDK completos para Node.js, Python,
PHP, Java, C#.

Compara la API de firma electrónica airSlate SignNow con otros servicios

Descubre lo que distingue an airSlate SignNow de sus competidores

Esta tabla muestra una lista parcial de las funciones disponibles en airSlate SignNow y DocuSign.

DocuSign

Plantillas ilimitadas

Campos básicos

Campos avanzados

Etiquetas de texto para la creación de campos

Firma integrada

Plan API intermedio +

Envío integrado

Plan API intermedio +

Invitaciones de firma basadas en la función

Invitaciones de firma libres

Envío en bloques

Plan API intermedio +

Informes

Plan API intermedio +

Personalización de marca

Plan API intermedio +

API de Sandbox

Precio

Plan profesional

$146_/mes

1000 docs/año

Iniciar prueba gratuita de API

Plan intermedio

$300_/mes

100 docs/mes

Curso de iniciación a la API de airSlate SignNow

Descubre los detalles de la configuración de flujos de trabajo de firma electrónica fáciles de usar y seguros para las aplicaciones y servicios que ya estás utilizando con airSlate Academy.

Más información

FAQs

A continuación, se muestra una lista de las preguntas y respuestas más comunes sobre la API de airSlate SignNow. Elige una pregunta para ver una respuesta detallada.

¿Necesitas ayuda? Contacta con soporte

Sigue estos sencillos pasos para probar la API de firma electrónica:

Crea una cuenta de Sandbox. Introduce tu dirección de correo electrónico en el formulario rápido para registrarte.
Valida tu cuenta. Sigue el enlace del correo electrónico para proceder con el registro.
Accede al Sandbox del desarrollador. Indica una contraseña para acceder a tu entorno de desarrollador.
Obtén tus credenciales. Accede a Claves -> Prueba la App para encontrar las credenciales de tu cuenta.
Genera un token de portador. Utiliza Postman o cualquier cliente que admita solicitudes de API para crear y validar tu token de portador.
Prueba la firma electrónica. Explora las posibilidades de airSlate SignNow y evalúa la API de firma electrónica.

Estos 6 sencillos pasos te ayudarán a integrar las firmas electrónicas en tu aplicación. Crea, envía y firma electrónicamente documentos directamente desde tu aplicación. ¡Prueba las eficaces funciones de firma electrónica y compara la API de airSlate SignNow con la de DocuSign!

Cómo funciona

Crea una cuenta y accede al Panel de control de la API

Copia el código requerido de la biblioteca para recopilar pagos junto con documentos firmados utilizando la API

Controla cómo crece tu productividad con los flujos de trabajo acelerados

Razones para elegir nuestra API de firma electrónica

Facilidad de integración

La solución firma electrónica de airSlate SignNow fue creada pensando en el usuario. Esta API de firma electrónica es capaz de integrarse con tu software en menos de diez minutos.

Eficiencia de costes

Nuestra eficiente solución de firma electrónica te permitirá ahorrar tiempo, dinero y complicaciones. Nuestros planes de precios de la API se adaptan a las necesidades de todo tipo de empresas.

Firma electrónica con marca personalizable

Edita y envía rápidamente tus documentos digitales con tu propia marca. Con la API de firma electrónica de airSlate SignNow podrás sacar partido de las funcionalidades de la firma electrónica al tiempo que conservas la marca de tu empresa.

Soporte 24/7

Ponte en contacto con nuestro equipo de soporte para cualquier duda que pueda surgir en el proceso de integración. ¡Estaremos encantados de ayudarte en todo momento!

Más información sobre nuestra API de firma electrónica

Integra las funcionalidades de la firma electrónica en tu aplicación

Acelera los tiempos de entrega de documentos proporcionando funciones de firma electrónica en tu aplicación/sitio web.

Más información

Envía invitaciones de firma por correo electrónico

Comparte enlaces a tus documentos por correo electrónico e invita a los destinatarios a abrirlos y firmarlos con solo unos clics.

Más información

Crea formularios rellenables

Recopila datos fácilmente integrando encuestas y cuestionarios personalizados en tu sitio web.

Más información

Crea plantillas

Sube un documento y guárdalo como una plantilla reutilizable con nuestra API de firma electrónica.

Más información

Configura recordatorios para los firmantes

Configura notificaciones automáticas para realizar el seguimiento de la finalización de documentos en tiempo real, sin tener que localizar documentos o firmas.

Más información

Comprueba el estado de tus documentos

Revisa informes de auditoría detallados y admisibles para visualizar todo el historial de acciones y cambios realizados en un documento.

Más información

¿Listo para empezar?

Es hora de ver la API de airSlate SignNow en acción. Crea tu cuenta de desarrollador y sube documentos, solicita firmas y comprueba el estado de tu documento.

Crear una cuenta sandbox Habla con el equipo de ventas

¿Por qué elegir la API de airSlate SignNow?:

Prueba gratuita y fácil de implementar
SDK para idiomas populares
Personalizable para cualquier flujo de trabajo
Cumplimiento y seguridad líderes en la industria

Inserta las firmas electrónicas
en tu flujo de trabajo.

Configura airSlate SignNow para que se adapte a las necesidades de tu empresa

Solución de firma electrónica personalizable

Precios competitivos y escalables

Configuración rápida

Alto índice de éxito

Funcionalidad flexible para cualquier caso de uso e industria

Funcionalidades de firma electrónica compatibles con la industria para tu aplicación

Opiniones de los clientes sobre nuestra API de firma electrónica

Selecciona un plan API para tu negocio

Ingenieros de soluciones

Revisar la documentación de la API de airSlate SignNow

Videoguías

Comienza con cualquiera de nuestros SDK

Compara la API de firma electrónica airSlate SignNow con otros servicios

Curso de iniciación a la API de airSlate SignNow

FAQs

¿Dónde puedo encontrar el panel de control de la API para administrar mis procesos?

¿Cómo creo una aplicación API?

¿Cómo accedo a los registros API? ¿Qué información se puede encontrar allí?

¿Cómo cargo documentos usando la API de sigNow?

¿Cómo agrego campos rellenables a un documento usando la API de airSlate SignNow?

¿Cómo creo una invitación de firma usando la API airSlate SignNow?

¿Cómo cancelo una invitación de firma enviada a través de la API de airSlate SignNow?

¿Cuál es la diferencia entre las invitaciones basadas en roles y la forma libre?

¿Puedo hacer envíos masivos de solicitudes de firma?

¿Puedo probar fácilmente la API de airSlate SignNow usando Postman?

Sigue estos sencillos pasos para probar la API de firma electrónica:

Cómo funciona

Razones para elegir nuestra API de firma electrónica

Más información sobre nuestra API de firma electrónica

Integra las funcionalidades de la firma electrónica en tu aplicación

Envía invitaciones de firma por correo electrónico

Crea formularios rellenables

Crea plantillas

Configura recordatorios para los firmantes

Comprueba el estado de tus documentos

¿Listo para empezar?

¿Por qué elegir la API de airSlate SignNow?:

Inserta las firmas electrónicas en tu flujo de trabajo.

Configura airSlate SignNow para que se adapte a las necesidades de tu empresa

Solución de firma electrónica personalizable

Precios competitivos y escalables

Configuración rápida

Alto índice de éxito

Funcionalidad flexible para cualquier caso de uso e industria

Funcionalidades de firma electrónica compatibles con la industria para tu aplicación

Opiniones de los clientes sobre nuestra API de firma electrónica

Selecciona un plan API para tu negocio

Ingenieros de soluciones

Revisar la documentación de la API de airSlate SignNow

Videoguías

Comienza con cualquiera de nuestros SDK

Compara la API de firma electrónica airSlate SignNow con otros servicios

Curso de iniciación a la API de airSlate SignNow

FAQs

¿Dónde puedo encontrar el panel de control de la API para administrar mis procesos?

¿Cómo creo una aplicación API?

¿Cómo accedo a los registros API? ¿Qué información se puede encontrar allí?

¿Cómo cargo documentos usando la API de sigNow?

¿Cómo agrego campos rellenables a un documento usando la API de airSlate SignNow?

¿Cómo creo una invitación de firma usando la API airSlate SignNow?

¿Cómo cancelo una invitación de firma enviada a través de la API de airSlate SignNow?

¿Cuál es la diferencia entre las invitaciones basadas en roles y la forma libre?

¿Puedo hacer envíos masivos de solicitudes de firma?

¿Puedo probar fácilmente la API de airSlate SignNow usando Postman?

Sigue estos sencillos pasos para probar la API de firma electrónica:

Cómo funciona

Razones para elegir nuestra API de firma electrónica

Más información sobre nuestra API de firma electrónica

Integra las funcionalidades de la firma electrónica en tu aplicación

Envía invitaciones de firma por correo electrónico

Crea formularios rellenables

Crea plantillas

Configura recordatorios para los firmantes

Comprueba el estado de tus documentos

¿Listo para empezar?

¿Por qué elegir la API de airSlate SignNow?:

Inserta las firmas electrónicas
en tu flujo de trabajo.