An online store manager used to spend up to 2 hours on contract approvals with clients — after integration with SignNow, the time was cut to 5 minutes. Connecting e-signature to a site often stalls due to complex JWT setup, SDKs, and lengthy approvals. SignNow from airSlate stands out with a simple REST API and affordable pricing. Our team has delivered over 30 such integrations — from small online stores to corporate portals. Average time savings on signing is up to 70%, and for a small business, that can mean saving up to $2,000 per month in manual labor costs. Contact us for a consultation — we will prepare a solution for your project.
How SignNow Reduces Document Workflow Costs
SignNow does not require purchasing an SDK or complex infrastructure. OAuth 2.0 and direct REST requests are sufficient. According to the official SignNow REST API, the system handles up to 1000 requests per minute — enough for any mid-sized business. Integration costs pay off in 2–3 months through reduced manual labor. Compare: manual contract approval takes an average of 2 hours, with SignNow — 5–10 minutes. SignNow is 3 times cheaper than DocuSign for small businesses, making it a cost-effective choice for online document workflow automation.
How to Set Up Authentication in SignNow
SignNow uses OAuth 2.0 with the client_credentials grant for server integrations. This is simpler than DocuSign — no JWT or Legacy Header needed. Here is how we obtain a token:
class SignNowAuthService
{
private string $baseUrl = 'https://api.signnow.com';
public function getToken(): string
{
$response = Http::withBasicAuth(
config('services.signnow.client_id'),
config('services.signnow.client_secret')
)->asForm()->post("{$this->baseUrl}/oauth2/token", [
'grant_type' => 'client_credentials',
'scope' => '*',
]);
$token = $response->json('access_token');
Cache::put('signnow_token', $token, now()->addMinutes(55));
return $token;
}
public function token(): string
{
return Cache::get('signnow_token') ?? $this->getToken();
}
}
The token lives for 3600 seconds; we cache it with a 5-minute buffer. For operations on behalf of a specific user, Password Grant is used, but in most cases client_credentials is sufficient.
Uploading a Document and Placing Fields
After authentication, we upload a PDF (max size 50 MB) and add signature fields. SignNow supports smart fields — if the PDF contains anchors like [[sig|req|signer1]], signature fields are placed automatically. This is more convenient than manually calculating coordinates.
class SignNowDocumentService
{
public function __construct(private SignNowAuthService $auth)
{}
public function uploadDocument(string $pdfPath, string $fileName): string
{
$response = Http::withToken($this->auth->token())
->attach('file', file_get_contents($pdfPath), $fileName)
->post('https://api.signnow.com/document');
return $response->json('id');
}
public function addSignatureFields(string $documentId, array $signers): void
{
$fields = [];
$roleIndex = 0;
foreach ($signers as $signer) {
$fields[] = [
'type' => 'signature',
'role' => $signer['role'] ?? "Signer {$roleIndex}",
'role_id' => (string)$roleIndex,
'required' => true,
'height' => 40,
'width' => 200,
'x' => 100,
'y' => 600,
'page_number' => 0,
];
$roleIndex++;
}
Http::withToken($this->auth->token())
->put("https://api.signnow.com/document/{$documentId}", ['fields' => $fields]);
}
}
We use anchors — this reduces integration time and eliminates field positioning errors.
How to Send a Document for Signing and Get Status
To send an invitation to signers, we use the invite method. SignNow allows setting reminders and expiration:
public function sendInvite(string $documentId, array $signers): string
{
$recipients = [];
foreach ($signers as $index => $signer) {
$recipients[] = [
'email' => $signer['email'],
'role' => $signer['role'] ?? "Signer {$index}",
'role_id' => (string)$index,
'order' => $index + 1,
'reminder' => [
'remind_before' => 0,
'remind_after' => 3,
'remind_repeat' => 2,
],
'expiration_days' => 30,
'subject' => 'Please sign the document',
'message' => "Hello, {$signer['name']}! Please sign the attached document.",
];
}
$response = Http::withToken($this->auth->token())
->post("https://api.signnow.com/document/{$documentId}/invite", [
'to' => $recipients,
'from' => config('services.signnow.sender_email'),
]);
return $response->json('status');
}
After signing, SignNow sends a webhook. We register the document.complete event and handle it:
// Register webhook
Http::withToken($this->auth->token())
->post('https://api.signnow.com/api/v2/events', [
'event' => 'document.complete',
'entity_id' => $documentId,
'action' => 'callback',
'callback_url' => route('webhooks.signnow'),
]);
// Handler
public function handleSignNowWebhook(Request $request): Response
{
$data = $request->json()->all();
if (($data['event'] ?? '') === 'document.complete') {
$documentId = $data['meta']['document_id'];
DownloadSignedDocumentJob::dispatch($documentId);
}
return response()->noContent();
}
Embedded Signing: Sign Without Leaving Your Site
If you need the client to sign without navigating away from your site, we use embedded signing — get a link (valid 60 minutes) and embed it in an iframe. This is a key feature for iframe signing.
public function getSigningLink(string $documentId, string $email): string
{
$response = Http::withToken($this->auth->token())
->post("https://api.signnow.com/link", [
'document_id' => $documentId,
]);
return $response->json('url');
}
This works in most browsers, but requires handling postMessage after completion.
Why Choose Embedded Signing?
Embedded signing eliminates redirects to a third-party service — the client stays on your site. This increases trust and conversion. The link is valid for 60 minutes; after signing, a postMessage is sent that your page catches. If deeper customization is needed, SignNow allows configuring the iframe color scheme.
SignNow vs DocuSign Comparison
| Criterion | SignNow | DocuSign |
|---|---|---|
| API | Pure REST, no SDK required | SDK available, but OAuth more complex |
| Embedded signing | Available, but limited UI | Advanced, with customization |
| Smart fields | Anchors in PDF | Field support via API |
| Price | Cheaper for SMB | More expensive, more features |
| Document storage | No fiscal storage | Built-in audit trail |
SignNow is more advantageous for mid-sized businesses due to API simplicity and pricing. The average cost per document signing is 2–3 times lower.
Typical Integration Mistakes
- Not caching the token — each request gets a new one, slowing down operations.
- Ignoring webhooks — without them, you won't know when a document is signed.
- Hardcoding field coordinates — better to use anchors.
- Not handling errors — SignNow returns 401 on token expiry, 404 on deleted documents.
Our Work Stages
| Stage | Duration | Result |
|---|---|---|
| Analysis | 1 day | Integration specification |
| OAuth setup | 0.5 day | Working token with caching |
| Upload and fields | 1 day | PDF upload, smart fields |
| Send and webhooks | 0.5 day | Invitations, event handling |
| Embedded signing (if needed) | 1 day | Iframe with signature |
| Testing | 0.5 day | Debugging, error handling |
What Our Integration Includes (Deliverables)
- OAuth setup and token caching
- Document upload and smart fields implementation
- Invite sending mechanism and webhook handling
- Embedded signing integration (if required)
- Tests and documentation writing
- Training for your team on system usage
- Post-integration support for 30 days
- Access to our monitoring dashboard for webhook logs
Timelines: basic integration — 2–3 business days, with embedded signing — 3–4 days. Pricing is individual after analysis.
Get a consultation — we will assess your project and propose a turnkey solution. Our team's expertise spans dozens of e-signature integrations. We guarantee reliability and deadlines. Contact us — we will prepare a commercial proposal within one day.