Planning an e-signature API integration.

If your business already runs on its own software, such as a booking system, a client portal or an internal tool, you may want documents to go out for signature without anyone opening a separate dashboard. This guide is for the developer or technical lead planning that work with the SignAndGo developer API.

Decide whether you need code at all

Before writing an integration, check whether an existing route already covers the job. SignAndGo connects to Xero, so completed signed PDFs can be filed there, and a Procore connection, for sending subcontracts and commitments from Procore, is in Procore's certification review. There are also connectors that let Claude and ChatGPT work with your envelopes, with consent given per envelope. If one of those fits, you may not need to build anything.

Build against the API when signing is a step inside your own product or process, and you want it to happen automatically.

What the API is for

At a high level, an integration usually does four things:

  1. Creates an envelope from a document your system produces, with the right recipients.
  2. Sends it for signature, so each recipient receives their own link by email.
  3. Learns when something happens to it, such as a recipient signing or the envelope completing.
  4. Retrieves the signed PDF and stores it against the right record in your system.

The signer's experience is the same as for any other envelope. They sign in a web browser with no account.

Keys and permissions

Access is by API key, created from your workspace settings. Treat a key like a password:

  • Keep it on your server. Never put it in a web page, a mobile build or anything a user can download.
  • Give each key only the permissions the integration needs. A process that only downloads signed documents does not need permission to send.
  • Store keys in your secrets manager, not in source code, and replace a key straight away if you think it has been exposed.

Webhooks instead of polling

Rather than asking the API every few minutes whether anything has changed, register a webhook: an address on your server that SignAndGo calls when an event happens on your envelopes. Webhook messages are signed, so your server can check each one genuinely came from SignAndGo before acting on it. Always verify that signature, and reject anything that fails.

Your webhook handler should be quick. Acknowledge the message, then do the slow work, such as downloading the signed PDF, in a background job.

Design habits that keep it reliable

  • Store the envelope ID against your own record the moment you create the envelope. Every later step depends on it.
  • Make handlers safe to run twice. Networks retry. If the same event arrives again, your system should recognize it and do nothing new.
  • Handle every outcome, not just completion. A recipient can decline, and an envelope can be voided. Decide what your system does in each case.
  • Do not assume order. Treat each event on its own and check the current state if you need to.
  • Log what you send and receive, without logging the key or document contents, so you can trace a problem later.
  • Keep a manual fallback. If your integration is down, staff should still be able to send from the dashboard.

Documents and fields

Decide early how fields will be placed. If your system generates the same document layout each time, a template saved from your own document keeps field positions consistent. For documents that vary, plan how your integration will indicate where each signer signs. Very large documents, running to hundreds of pages, are supported, so long contracts and bundles do not need splitting.

Testing before you go live

Use your own email address for every recipient while you build. Run the full cycle: create, send, sign on a phone and a laptop, decline once on purpose, and void one envelope. Check that your webhook handler processes each event and that the signed PDF lands in the right place with its audit certificate. Only then point it at real customers.

Security reminders

Documents are kept securely on Google Cloud, encrypted at rest and in transit. Your side of the integration matters just as much. Use HTTPS for your webhook address, restrict who can read logs, and remove access for keys and staff who no longer need it. The security questions guide covers the broader picture.

Getting started

For API documentation and questions about a planned integration, email privacy@myandgo.ai with a short description of what you want to build. To see the signing flow your users will experience, read how it works.

Frequently asked questions

Do signers need an account when an envelope is created through the API?
No. They receive a link by email and sign in a web browser, the same as any other envelope.
Should I poll the API for status?
Prefer webhooks. SignAndGo calls your server when something happens, and each message is signed so you can verify it.
Is there a way to connect without writing code?
Possibly. Check the Xero and Procore integrations and the Claude and ChatGPT connectors before building your own.

See SignAndGo for your team

Send your first envelope in a few minutes, and keep every signed copy with its audit trail.

See how it works