How PactSafe Gives Developers Innovative eSignature Alternatives

As a developer, you might have gotten the request at some point to add "electronic signature" (eSignature) to the apps that you're building. It could be with uploaded documents, accepting Terms of Service when signing up, or assembling a document on the fly. I'm here to tell you that it doesn't have to suck to build this kind of solution (or integration). It may not be why you think, though—most developers don't know that there are many different ways to enter into a legally binding agreement digitally.

A common misconception in the electronic signature world is that the only way a contract can be signed digitally in the U.S. is by "DocuSigning" the agreement in document form. Not true. Contracts can be executed by email, SMS, click-through, and more. At PactSafe we've built an API for developers to explore completely native, innovative ways to execute agreements and it's high time we think the UX and development folks should decide how and when contracts are executed—not the eSignature providers. We've pioneered how contract execution is presented and tracked inside Web and mobile apps, and we're opening the kimono on how you can streamline your own workflows to follow suit.

 

Click-through agreements

Click-through agreements (also called "clickwraps") can be used in almost all contract flows for standardized agreements that you're using to present to your users. These types of agreements happen all the time in login and purchase flows in e-commerce websites and apps like Uber and Instacart. Click-through agreements come in forms like Non-Disclosure Agreements (NDAs), Employment Agreements, Terms of Service, Privacy Policies, and more. You can embed the clickwrap contract on the page or provide a checkbox input with a link referencing online terms hosted on a landing page or microsite.

Of course, it's important to track who and how people accept the contract - this is where PactSafe comes in. PactSafe also allows you the flexibility to choose and design how and where your click-through agreements are presented.

When executing click-through agreements, you'll want to track the following things:

  • Who accepted (name, email, IP address, device)
  • Contract that was accepted (version, body of the agreement, etc.)
  • URL where it was accepted

Using an API, SDK, or library like PactSafe for this type of solution makes it easy to load the contract into any <div> on the page:

HTML:
<script>
_ps('load', 'click-through-1', { container_selector: "contracts-div" });
_ps('set', 'signer_id', 'eric@pactsafe.com');
_ps('set', 'custom_data', { first_name: "Eric", last_name: "Prugh" });
</script>
<div id="contracts-div"></div>

The above code will result in something like this that gives you a Contract for your user to accept right within your app, in native code:

Click through Agreements

Accept contracts via SMS

SMS is another amazing way to capture acceptance of a contract that you wouldn't normally think about when wanting to embed esignature processes into your app. The same way an eSignature can offer up a binding contract, replying to an SMS message with "Accept" or "Agree" acts much the same way for almost all agreements.

With PactSafe, we offer a multi-channel "Signature Request" API that allows you to choose a method for delivery and, in some cases, acceptance for an electronic signature. You can embed a signature pad on a document, present a simple "accept" button, or send an SMS that will accept an "Agree" response and complete the contract in real-time.

It's super easy to send a contract template for eSignature with PactSafe (note the "contracts" property is an array of contract template IDs). There's a sequence of two calls that will enable you to send your contract. First, you can do an HTTP GET call to create the request. In the response, you'll get a Request ID.

1. HTTP GET https://api.pactsafe.com/v1.1/requests

REQUEST (JSON):

{
 "name":"Contract",
 "contracts": [
   10741
 ],
 "signers": [
   {
     "signer_id":"(317) 123-4567",
     "send_to": {
       "mobile_number": true
     }
   }
 ]
}

RESPONSE (JSON):

{
 "data": {
   "name": "Contract",
   "signers": [
     {
     "_id": "(317) 123-4567",
       "signer_id": "(317) 123-4567",
       "signer": {
         "mobile_number": "+13171234567",
         "uuid": "58c01032155f703aef8eb226"
       },
       "sent": false,
       "send_to": {
         "mobile_number": true,
         "email": false
       },
       "role": "signer"
     }
   ],
   "contracts": [
     {
       "revision_number": 1,
       "id": "58c010c9f28c533a7bccf0a3"
     }
   ],
   "id": "58c010c9f28c533a7bccf0a2"
 }
}

Note the Request ID at the very bottom of the request. To send, you just POST back to the /send call to finish your call, where it will send the SMS and see the request through to completion:

2. HTTP POST https://api.pactsafe.com/v1.1/requests/58c010c9f28c533a7bccf0a2/send

No BODY required!

That creates a super simple flow for your signer to execute the agreement:

SMS

Redirect to a responsive, HTML/native contract signing page

All esignature providers out there force you to upload raw documents to their platform to process signatures. There's another way—you're designing for mobile, so why can't esignatures look great on mobile? PactSafe is the only esignature API that allows you to translate Word Docs to HTML to make them responsive for signing.

Eric Prugh Tech executive, recovering developer, SaaS obsessed, platform builder. I love the interconnectivity of systems and how they can solve business problems. Was a product leader at ExactTarget & Salesforce and am now a co-founder of PactSafe.
 

Comments