Create and send agreements straight from your own systems. Build a template once, then send it to signers with a single API call. FlexiSign is made for automated sending, not embedded signing.
Use it to send documents for signature on autopilot. You keep your templates in FlexiSign, and the API handles the sending.
Trigger signature requests from your app, CRM, or workflow tool. Once it is set up, no one has to send anything by hand.
Build a template once in FlexiSign, then reuse it on every call. Pass the signer names and emails, and the API does the rest.
The API creates and sends agreements. It is not an embedded signing widget, so it stays small and easy to work with.
The FlexiSign electronic signature API uses API key authentication. Generate an API key in your account, copy it, and send it as the api-key header on every request. Your key is tied to a workspace, so the API returns the templates in that workspace.
Create your templates in FlexiSign first. Once a template is ready, the three calls below let you list your templates, read a template's signer details, and send a new agreement.
You must build your templates in FlexiSign before you can send them through the API. The API reads and sends templates, it does not create documents from scratch.
List your templates, read one template's signer details, then create the document. That is the whole flow.
Retrieve every template in your workspace. The response lists each template with its id and name.
curl --location 'https://api.flexisign.io/v1/templates/all' --header 'api-key: Your_API_Key'{
"data": {
"list": [
{
"_id": "66800easja46ed5ca7e63036f9",
"name": "Eszmeletlen Holding Co. Proposal.pdf"
}
]
}
}Pass a template id to read its signer roles and the fields you need to fill. The recipient details and their variables come back in the bodyStructure object.
curl --location --globoff 'https://api.flexisign.io/v1/template?templateId={_id}' --header 'api-key: Your_API_Key'{
"data": {
"template": {
"_id": "66800easja46ed5ca7e63036f9",
"name": "Eszmeletlen Holding Co. Proposal.pdf",
"recipients": [
{
"role": "Owner",
"name": "Template Owner",
"email": "Owner@make.io"
}
],
"bodyStructure": {
"en_message": "string",
"recipient_0_email": "string",
"recipient_0_name": "string",
"recipient_1_email": "string",
"recipient_1_name": "string",
"recipient_2_email": "string",
"recipient_2_name": "string",
"recipient_3_email": "string",
"recipient_3_name": "string",
"recipient_4_email": "string",
"recipient_4_name": "string",
"recipient_5_email": "string",
"recipient_5_name": "string",
"expiresIn": 60
}
}
}
}Send the template id along with the signer names, emails, and a message. The API creates the agreement from the template and sends it out for signature.
curl --location 'https://api.flexisign.io/v1/template/create-document' --header 'api-key: Your_API_Key' --header 'Content-Type: application/json' --data-raw '{
"templateId": "Template ID",
"en_message": "Please sign this document",
"recipient_0_email": "recipient0@make.io",
"recipient_0_name": "Recipient Name 0",
"recipient_1_email": "recipient1@make.io",
"recipient_1_name": "Recipient Name 1",
"recipient_2_email": "recipient2@make.io",
"recipient_2_name": "Recipient Name 2",
"recipient_3_email": "recipient3@make.io",
"recipient_3_name": "Recipient Name 3",
"recipient_4_email": "recipient4@make.io",
"recipient_4_name": "Recipient Name 4",
"recipient_5_email": "recipient5@make.io",
"recipient_5_name": "Recipient Name 5",
"expiresIn": 60
}'It lets you create and send agreements from your own systems. You build a template in FlexiSign, then use the API to send it to signers. It is made for automated sending.
No. FlexiSign is not an embedded signing app. The API creates and sends agreements, and signers complete them on FlexiSign's hosted signing pages.
Generate an API key in your account and send it as the api-key header on every request. Your key is tied to a workspace, so the API returns the templates in that workspace.
You create them in FlexiSign first. The API reads the templates in your workspace and sends them, so you cannot build a document from scratch through the API.
A template supports the recipient fields shown in its bodyStructure, from recipient_0 up to recipient_5.
It sets how long the signature request stays open before it lapses. You pass it in the create document call.
Generate an API key, point it at your templates, and send your first document. The e-signature API is ready when you are.