Signing, inside the work. Not beside it.
Scribble is a signing service your business applications call directly. The system that holds the agreement sends it, the people who need to sign are guided through it on any screen, and the signed PDF and its audit evidence come back to the record they belong to.
In use every day. We run Scribble across the businesses we own to embed document signing directly inside our operational apps.
The agreement lives in your system. The signature does not.
When signing happens in a separate tool, someone exports the document, sends it, chases it, downloads the result and files it back by hand. Every step outside the system is a step where the record and the signed copy can drift apart.
- Agreement prepared in your application
- Exported and uploaded to a signing tool Leaves the system
- Signers chased by hand Outside the record
- Signed copy downloaded and filed back Manual step
- The record says signed, if someone remembered to update it
- Your application creates the signing request from the record
- Signers are invited in the order you set
- Each one is guided field by field, on a phone or a desktop
- The signed PDF and its audit document are kept, unaltered
- Your application is told the moment it is done
For teams whose software already holds the agreement, and who need the signature to come back to it.
Follow one request from draft to evidence.
Your application talks to Scribble through a private API. Choose a stage to see what happens to the document, the signers and the record.
Your application creates the request
It sends the PDFs, the signers and the fields to fill. The request can start as a draft for someone to review, or go out straight away.
- Bundle every document and signer your agreement needs in one request
- Signature, initials, date, text, number and file fields
- A retried call never creates a second request
The first signer is invited
By email, or through a private signing link that your application presents to the signer itself. Signers can switch between French and English.
- Built-in reminders keep agreements moving without manual chasing
- A signer can decline and give a reason
- The request can be cancelled; its links stop working
Signers sign in the order you set
The next person is invited only when the one before has finished. Your application can read the status of the request and of each signer at any time.
- Each signer is waiting, invited, opened, completed or declined
- Private, time-limited signing links keep every document protected
- Ordered signing ensures each party signs at the exact step they belong
The signed copy and its evidence are kept
The signed PDFs, the audit document and any files signers uploaded are stored privately, exactly as produced, each with a SHA-256 fingerprint.
- An evidence summary lists the signers, times and fingerprints
- Stored copies are not modified afterwards
- Nothing is deleted automatically
Your application is told it is done
Only once the signed copy is stored, Scribble sends a signed notification to your system, so it can attach the document to the record and move on.
- Notifications are signed so your system can verify them
- Failed deliveries are retried for several hours
- Your system can download the signed files and evidence
One field at a time. Nothing to install.
Signers open a private link in their browser. Scribble walks them through every field in order, so nobody has to hunt through a long document for the line they missed.
-
Start, Next, Finish
The signer is taken to each field in turn and cannot finish while a required one is empty.
-
Sign once, apply with a tap
Initials and signature are entered once, then placed on each later field with a single tap. Nothing is applied without one.
-
Dates fill themselves in
Signing dates are added automatically for each signer.
-
French or English
The signing page, invitations and reminders are available in both. Switching language keeps a signature already drawn.
-
Comfortable on a phone
Zoom, fit to page and a reading mode for long documents. On a phone, the controls sit below the document.
Multi-document bundles. Prefilled from your data.
Send a single PDF or a full multi-document signing packet. Scribble renders prefilled values from your system into exact field coordinates, locks what should not change, and leaves the rest ready for the signer.
Bundle any documents together
Combine agreements, schedules, warranties and addenda into one seamless signing packet with clear recipient-facing titles.
Six field types, including file uploads
Place signature, initials, date (DD/MM/YYYY or YYYY-MM-DD), text, number and optional or required file-upload fields so signers can attach IDs or supporting documents right inside the signing flow.
Smart prefill and lock-when-filled
Pass known values from your CRM, HR or billing system. Filled values render cleanly into the PDF and lock automatically, while missing fields stay editable for the signer.
Versioned, immutable templates
Register approved recurring templates with fixed field geometry and bounded typography. Publish a new version anytime while every past signed bundle keeps its exact original snapshot and bytes.
Draft review before sending
Create a server-rendered preview draft first so staff can verify every prefilled field before any signer receives an invitation or private link.
Multi-party signing in your exact order
Assign roles and signing order across customers, co-signers, managers and internal approvers. Each party is invited only after the previous one completes.
Built for the agreements your software already drives.
Because Scribble is called directly by your applications, every signed document lands back on the exact record that triggered it — no manual downloads, no re-filing.
Financing & commercial bundles
Multi-document contracts, warranty terms and disclosures prefilled from your deal record, signed in sequence on a phone or desk, with signed PDFs and uploaded proofs returned automatically.
HR & employee agreements
Offer letters, accountability agreements, policy sign-offs and action plans sent from your staff portal in English or French, with automatic date stamping and tamper-evident history.
Franchise & vendor onboarding
Franchise disclosures, lease schedules and supplier agreements routed across legal, franchisee and head office in strict order, with reminders and instant link invalidation if cancelled.
Client proposals & work orders
Statements of work, service contracts and change orders where a completed signature fires a verified webhook to kick off project delivery and billing right away.
Built for production. Ready to connect.
Everything you need to run document signing inside your software — from multi-document bundles to tamper-evident archival and verified webhooks.
RequestsWhat a single request can carry.
- Several documents, several signers
Bundle every PDF and signer your workflow requires into one request, each with a clear role and signing order.
- Fields that fit the document
Signature, initials, date, text, number and file upload. Fields can be optional, read-only or filled in ahead of time.
- Review before sending
Start as a server-rendered draft so your team can review every prefilled field before anything goes out.
- Approved templates
Recurring documents can be registered as fixed, reviewed templates that your application can list and reuse.
- Verified cancellation and decline
Signers can decline with a reason. Cancelling a request immediately expires every active link and verifies the ceremony is closed.
IntegrationHow your software connects.
- A private, server-to-server API
Your application calls Scribble from its own server with a key that only reaches your organization's requests.
- Safe to retry
Every write carries a unique key, so a repeated call returns the same request instead of creating a duplicate.
- Signed completion notifications
Your system is notified when a request is complete, with a signature it can verify and retries if it is unreachable.
- Links your app can present
Your application can ask for a private signing link per signer and send people there itself, instead of by email.
- Webhook retries and replay
Completion callbacks carry HMAC-SHA256 signatures, retry with exponential backoff over several hours, and can be replayed on demand without duplicating records.
EvidenceWhat is kept once it is signed.
- The signed PDF and its audit document
Stored privately, exactly as produced, with a SHA-256 fingerprint for each file.
- An evidence summary
Who signed, when, and the fingerprints of every stored file, available to your application on request.
- Built-in PDF security checks
Encrypted, damaged or active-content PDFs are caught automatically before anyone is asked to sign.
- No automatic deletion
Signing records are not deleted automatically. Retention terms are agreed with each organization.
- Private downloads with digest checks
Signed PDFs, audit certificates and signer attachments are served only through authenticated routes with SHA-256 verification and forced-download headers.
OperationsWhat we run for you.
- Each organization kept apart
Requests, documents and keys are separated per organization; one cannot see another's.
- Usage you can check
Each completed request is counted once, however many files or signers it had, and never twice on a retry.
- Run by our team
We set up each organization and its connection, issue and rotate keys, and watch delivery from our own console.
- Backed up daily
Records and evidence are backed up off the server every day, and restoring them has been tested.
- Scoped API keys and safe rotation
256-bit bearer keys scoped separately for documents, signing and links, with atomic key rotation and instant revocation.
Tell us what needs signing.
The documents, who signs them, and how it happens now.
The application that holds it, and what it needs back once it is signed.
How we connect Scribble to your workflow and get your first documents signing fast.