TL;DR: A representational state transfer (REST) API lets your app call an eSignature service over the web from any language. A software development kit (SDK) wraps those same calls in ready-made functions for one language, so you write less code. The BoldSign eSignature API offers both, and you can mix them in one project.
Say you want customers to sign contracts without leaving your app. You have picked an eSignature API provider, and now you face the first build choice. Do you call the REST API yourself, or install the provider’s SDK?
Both routes send the same documents and return the same results. This guide explains each one in plain terms, compares them and shows the same signing request written both ways.
What is a REST API?
A REST API is a set of web addresses that your app sends requests to over the Hypertext Transfer Protocol (HTTP). Each address stands for one thing, such as a document, and each request stands alone.
Think of it as a public mailbox with a known address. Anyone can post a letter, in any language, as long as the envelope follows the rules. The service reads the request and posts a reply back.
How does a REST API call work?
- Your app sends a request to a web address, with your key in a header.
- The server checks the key and handles the request.
- The server returns a status code and data, usually in JavaScript Object Notation (JSON).
What is an SDK?
An SDK is a library for one programming language that comes with documentation and sample code. It wraps the API’s web requests in functions, so you skip the repeated setup code.
If the REST API is the mailbox, an eSigning SDK is a prepaid envelope with the address already printed. You fill in the details and drop it in.
How does an SDK call work?
- Install the SDK with your language’s package manager, for example
pipfor Python. - Create a client with your API key.
- Call a method such as
send_document()and read the returned object.
REST API vs SDK: how do they compare?
The two routes reach the same endpoints. They differ in how much code you write and how much control you keep.
| Point | REST API | SDK |
|---|---|---|
| Setup | Write requests, headers and parsing yourself | Install a package and call methods |
| Languages | Any language that can make HTTP requests | Only the languages the provider ships |
| Size | No extra library | Adds a package and its dependencies |
| Control | Every header and field is yours to set | Limited to the methods the SDK offers |
| Upkeep | You track API changes yourself | The provider updates the package |
When should you use a REST API or an SDK?
Pick the REST API when your language has no SDK or you need full control. Pick an SDK when your stack matches one and speed matters most.
When does a REST API fit?
- Your app runs in a language that has no official SDK.
- One status dashboard reads signing events for several platforms, such as web and mobile.
- You want to keep dependencies to a minimum.
- You want to call a new endpoint the day it ships.
When does an SDK fit?
- Your back end runs on a language the provider supports, such as Python.
- You want to ship a first signing flow quickly.
- You prefer typed objects and editor hints over hand-built requests.
How should developers compare electronic signature APIs for SDKs, webhooks, and authentication?
Check that the SDKs cover your language, that webhooks report each signing event, and that sign-in suits your app. These points decide how much code you write and maintain.
- Is there an official SDK for your language, and is it kept up to date?
- Do webhooks tell your app when a document is viewed, signed or declined?
- Can you use an API key for your own server and OAuth 2.0 for user accounts?
- Can you try every call in a free sandbox before you go live?
BoldSign covers all four. Our guide to API keys vs OAuth explains the two sign-in methods, and why webhooks matter in API integration covers event updates.
How do you send a document with the BoldSign REST API?
You post the PDF and the signer details to one endpoint, with your API key in the X-API-KEY header. This is REST API document signing at its simplest, and it works from any language that can send HTTP requests.
Here is the request in Python, using the requests library.
import json
import requests
url = "https://api.boldsign.com/v1/document/send"
signer = {
"name": "Hanky",
"emailAddress": "hanky@example.com",
"signerType": "Signer",
"locale": "EN",
"formFields": [
{
"id": "sig1",
"name": "sig1",
"fieldType": "Signature",
"pageNumber": 1,
"bounds": {"x": 50, "y": 50, "width": 200, "height": 50},
"isRequired": True,
}
],
}
payload = {"Title": "Agreement", "Signers": json.dumps(signer)}
headers = {
"accept": "application/json",
"X-API-KEY": "YOUR_API_KEY",
}
with open("NDA.pdf", "rb") as pdf_file:
files = {"Files": ("NDA.pdf", pdf_file, "application/pdf")}
response = requests.post(url, headers=headers, data=payload, files=files)
print("Status:", response.status_code)
print(response.text)
The signer gets an email with a link to sign the contract. You can use webhooks to track its status as it changes.
To try it, generate an API key in BoldSign. The BoldSign API documentation lists every endpoint and field.
How do you send a document with a BoldSign SDK?
Install the SDK for your language, create a client with your API key and call one method. We offer five official SDKs:
Here is the same request with the Python SDK.
import boldsign
configuration = boldsign.Configuration(api_key="YOUR_API_KEY_HERE")
with boldsign.ApiClient(configuration) as api_client:
document_api = boldsign.DocumentApi(api_client)
signature_field = boldsign.FormField(
fieldType="Signature",
pageNumber=1,
bounds=boldsign.Rectangle(x=50, y=50, width=200, height=50),
isRequired=True,
)
signer = boldsign.DocumentSigner(
name="Hanky",
emailAddress="hanky@example.com",
signerType="Signer",
formFields=[signature_field],
)
send_for_sign = boldsign.SendForSign(
title="Freelance Agreement", signers=[signer], files=["NDA.pdf"]
)
response = document_api.send_document(send_for_sign=send_for_sign)
print(response.document_id)
As with the REST API, the signer gets a signing link by email. Install the SDK with pip install boldsign and run the sample against your sandbox. The Python SDK documentation shows more methods.
Which BoldSign plan do you need for API access, and what does it cost?
Testing in the sandbox is free, so you can try both the REST API and the SDKs before you pay. Live API calls, webhooks and embedded signing need the Enterprise API plan.
The Enterprise API plan starts at $30 a month with 40 envelopes, billed yearly. Each extra envelope costs $0.75. Prices are in USD, as of November 2026, and the pricing page lists every plan.
Which should you try first, the REST API or an SDK?
Start with the SDK for your language, and drop to the REST API where you need more control. Both use the same key and the same sandbox.
- Create a free API sandbox account and send your first test document.
- Read the SDK overview to pick the package for your stack.
- Ask a question on our support portal while you build.
Frequently asked questions
What is the difference between a REST API and an SDK?
A REST API is the set of web addresses your app calls over HTTP. An SDK is a library for one language that makes those calls for you, so you write method calls instead of raw requests.
Is an SDK faster to build with than a REST API?
Usually, yes. The SDK already handles headers, request bodies and response objects, so you write less code. The REST API takes more setup but works from any language.
I need a REST API just for sending documents out for signature, what should I use?
Use an eSignature API that sends a document with one request, such as the BoldSign send document endpoint. You post the file and the signer details, and we email the signer a link to sign.
Which languages do the BoldSign SDKs support?
We offer five official SDKs, for .NET (C#), Python, Java, Node.js and PHP (the web scripting language). From any other language, you call the REST API directly over HTTP.
Can I use the REST API and an SDK in the same project?
Yes. The SDKs call the same REST API, so you can send documents with the SDK and call a newer endpoint directly where you need it.
How does BoldSign authenticate API requests?
We accept two methods: an API key in a request header, or OAuth 2.0 access tokens. An API key suits your own back end, and OAuth suits apps where users connect their own accounts.
Can I test the BoldSign API for free?
Yes. Testing in the sandbox is free. Sandbox documents carry a test watermark and are deleted after 14 days, so they never count as real signed records.
How much does the BoldSign API cost?
Live API use starts at $30 a month with 40 envelopes, billed yearly, on the Enterprise API plan. Each extra envelope costs $0.75. Prices are in USD, as of November 2026.