Integrate eSignatures into your legal workflows

airSlate SignNow API enables legal teams and law firms to streamline eSignature workflows, improve customer experience, and cut agreement turnaround times — all while staying secure and compliant.

Free to test
Fast to deploy
Powerful & secure

Learn more about airSlate SignNow API

Fill out this form and one of our sales reps will contact you shortly to advise on the right API solution for your needs.

Asterisk denotes mandatory fields

Asterisk denotes mandatory fields (*)

Phone number*

Interested in APIInterested in API

By clicking "Submit Request" I agree to receive marketing communications from airSlate SignNow in accordance with the Terms of Service and Privacy Notice

Address the challenges of your legal business with embedded eSignatures

Flexible eSignature API for the legal industry

Enable seamless contract journeys within your software solution. Easily send documents for signature, request payments, create reusable templates with fillable fields, and track the status of documents in real-time.

Upload a PDF and create fillable fieldsAdd fields to documents to create fillable PDFs

Send a document for signatureInvite others to fill out and sign forms via email

Track document completion statusGet notified once the document is completed

Download and save signed documentsTake advantage of a powerful eSignature API

Copy code

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 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 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"";
    }

View all API features View full API reference

Simplify legal paperwork and collect signed agreements inside your app or website with airSlate SignNow’s eSignature API

Tired of chasing unsigned contracts and rectifying typos in completed agreements? Save time and hassle with the airSlate SignNow API. Empower your customers to seamlessly sign and track legal documents without leaving your website or application.

Brandable eSignature solution

Customize signature invitations with your branding.

Sandbox account

Test the eSignature API for free with the developer sandbox.

Quick setup

Detailed API documentation and clear coding examples ensure an excellent developer experience.

High success rate

Enjoy superior app performance with our 24/7 API monitoring.

Legal professionals choose the airSlate SignNow API

“Once we got the API working, it went really smoothly. Now it’s working like a well-oiled machine.”

Read full story

Select an API package for your business

Integrate eSignatures into your software and get 250 legally-binding signature invites with your API free trial.

Contact Sales

Solution engineers

We are here to help you configure eSignature API to your workflow.

Review airSlate SignNow’s API documentation

The detailed API tutorial will guide you through the entire integration process and provide clear coding examples.

Video guides

Watch our video guides for instructions on how to easily build custom integrations.

Start with any of our SDKs

Get complete SDKs for Node.js, Python,
PHP, Java, C#.

API stats & trends

The number of airSlate SignNow API customers is growing every day. New customers inspire our team to maintain stability, improve documentation, and develop new features to simplify your document processes. We’d like to share the results you’ve helped us achieve.

1.2M

average number of documents sent in a week

21,731

total number of registered sandboxes

99.99%

API uptime

250

signature invites per free trial

SDKs

for 5 languages

1,412

average number of applications created per week

FAQs

Below is a list of the most common questions and answers about airSlate SignNow’s eSignature API. Choose a question to view a detailed answer.

Need help? Contact support

Ready to get started?

It’s time to see airSlate SignNow’s document generation API in action. Create your developer account and upload documents, request signatures, and check the status of your documents.