TL;DR: A qualified electronic signature (QES) is the EU signature level that counts the same as a handwritten one. With the BoldSign API, you turn QES on once in your account, then set
EnableQesto true on a signer when you send. Our QES page explains how the signer’s identity is checked.
Some contracts need more than a typed name or a drawn signature. A loan agreement or a cross-border contract in the EU may need proof that a trusted third party checked who signed.
You can add that proof to the documents your app already sends. This guide shows what QES is, the code that sends a QES request, what your signer sees, and the rules to plan around.
What is a qualified electronic signature API?
A qualified electronic signature API lets your app send documents that signers complete with a QES. The signer’s identity is checked by a qualified trust service provider (QTSP) before they sign.
Think of a notary who looks at your passport before you sign a deed. A QTSP plays that role online. It checks the signer’s ID and issues a qualified certificate that is bound to the signature.
Our guide to QES compliance covers the standard in more depth.
Why does a QES carry more legal weight?
EU rules on electronic identification, authentication and trust services (eIDAS) give a QES the same legal effect as a handwritten signature. Article 25 of Regulation (EU) No 910/2014 says so directly.
The same article says a QES based on a qualified certificate from one member state is recognised in all the others. Other electronic signatures still have legal effect, but a court weighs them case by case.
Read our overview of QES regulations in the EU to see when a QES may be required.
How to send secure documents with QES through the BoldSign API
You turn QES on once for your account, then switch it on for each signer in your request. The steps below take you from settings to a sent document.
Step 1: Turn on QES in your business profile
- Open Settings, select Business Profile, then open the Settings tab.
- Scroll to Qualified electronic signature (QES) and turn it on.
- Set the Number of verification attempts from 1 to 10, then select Save changes.
- Next to Signature providers, select Configure to choose providers by country.
QES is off by default. Without the add-on, a dialog asks you to select Contact Support, and our team turns it on. The help article on enabling QES in your business profile shows each screen.
Step 2: Install a software development kit (SDK) and create your API key
Install the SDK for your language with the SDK installation guide. Then create a key with the API key generation guide.
Step 3: Set EnableQes to true on the signer
Add "EnableQes": true to each signer who should sign with a QES. The send document reference describes the property.
Example code snippets:
curl -X POST \
'https://api.boldsign.com/v1/document/send' \
-H 'accept: application/json' \
-H 'X-API-KEY: {your API key}' \
-H 'Content-Type: application/json' \
-d '{
"Title": "Sampledocument",
"Signers": [
{
"Name": "Alex",
"EmailAddress": "alex@example.com",
"SignerType": "Signer",
"EnableQes": true,
"FormFields": [
{
"Id": "string",
"Name": "string",
"FieldType": "Signature",
"PageNumber": 1,
"Bounds": {
"X": 50,
"Y": 50,
"Width": 125,
"Height": 25
}
}
]
}
],
"Files": [
"data:application/pdf;base64,JVBERi0xLjcKJcfs..."
]
}'
var apiClient = new ApiClient("https://api.boldsign.com", "Your_API_Key");
var documentClient = new DocumentClient(apiClient);
var formField = new List<FormField>
{
new FormField(
id: "Signature",
type: FieldType.Signature,
pageNumber: 1,
bounds: new Rectangle(x: 50, y: 50, width: 200, height: 30))
};
var documentDetails = new SendForSign
{
Title = "Agreement",
Signers = new List<DocumentSigner>
{
new DocumentSigner(
signerName: "Alex",
signerType: SignerType.Signer,
signerEmail: "alex@example.com",
formFields: formField)
{
EnableQes = true
}
},
Files = new List<IDocumentFile>
{
new DocumentFilePath
{
ContentType = "application/pdf",
FilePath = "YOUR_FILE_PATH",
}
},
};
var documentCreated = documentClient.SendDocument(documentDetails);
import boldsign
configuration = boldsign.Configuration(api_key="YOUR_API_KEY")
with boldsign.ApiClient(configuration) as api_client:
document_api = boldsign.DocumentApi(api_client)
form_field = boldsign.FormField(
fieldType="Signature",
pageNumber=1,
bounds=boldsign.Rectangle(x=50, y=50, width=200, height=25),
)
document_signer = boldsign.DocumentSigner(
name="Alex",
emailAddress="alex@example.com",
signerType="Signer",
formFields=[form_field],
enableQes=True,
)
send_for_sign = boldsign.SendForSign(
title="Document SDK API", files=["YOUR_FILE_PATH"], signers=[document_signer]
)
document_created = document_api.send_document(send_for_sign)
<?php
require_once "vendor/autoload.php";
use BoldSign\Configuration;
use BoldSign\Api\DocumentApi;
use BoldSign\Model\{FormField, Rectangle, DocumentSigner, SendForSign, FileInfo};
$config = new Configuration();
$config->setApiKey('YOUR_API_KEY');
$document_api = new DocumentApi($config);
$form_field = new FormField();
$form_field->setFieldType('Signature');
$form_field->setPageNumber(1);
$bounds = new Rectangle([100, 100, 100, 50]);
$form_field->setBounds($bounds);
$document_signer = new DocumentSigner();
$document_signer->setName("Alex");
$document_signer->setEmailAddress("alex@example.com");
$document_signer->setSignerType("Signer");
$document_signer->setFormFields([$form_field]);
$document_signer->setEnableQes(true);
$send_for_sign = new SendForSign();
$files = 'YOUR_FILE_PATH';
$send_for_sign->setFiles([$files]);
$send_for_sign->setSigners([$document_signer]);
$send_for_sign->setTitle('Document SDK API');
$document_created = $document_api->sendDocument($send_for_sign);
ApiClient client = Configuration.getDefaultApiClient();
client.setApiKey("YOUR_API_KEY");
DocumentApi documentApi = new DocumentApi(client);
FormField signatureField = new FormField();
signatureField.setFieldType(FormField.FieldTypeEnum.SIGNATURE);
signatureField.setPageNumber(1);
Rectangle bounds = new Rectangle().x(100f).y(100f).width(100f).height(50f);
signatureField.setBounds(bounds);
DocumentSigner signer = new DocumentSigner();
signer.setName("Alex");
signer.setEmailAddress("alex@example.com");
signer.setSignerType(DocumentSigner.SignerTypeEnum.SIGNER);
signer.setFormFields(Arrays.asList(signatureField));
signer.setEnableQes(true);
SendForSign sendForSign = new SendForSign();
File file = new File("YOUR_FILE_PATH");
sendForSign.setFiles(Arrays.asList(file));
sendForSign.setSigners(Arrays.asList(signer));
sendForSign.setTitle("Document SDK API");
DocumentCreated documentCreated = documentApi.sendDocument(sendForSign);
import { DocumentApi, DocumentSigner, FormField, Rectangle, SendForSign } from "boldsign";
import * as fs from "fs";
const documentApi = new DocumentApi();
documentApi.setApiKey("YOUR_API_KEY");
const bounds = new Rectangle();
bounds.x = 100;
bounds.y = 50;
bounds.width = 100;
bounds.height = 100;
const formField = new FormField();
formField.fieldType = FormField.FieldTypeEnum.Signature;
formField.pageNumber = 1;
formField.bounds = bounds;
const documentSigner = new DocumentSigner();
documentSigner.name = "Alex";
documentSigner.emailAddress = "alex@example.com";
documentSigner.signerType = DocumentSigner.SignerTypeEnum.Signer;
documentSigner.formFields = [formField];
documentSigner.enableQes = true;
const files = fs.createReadStream("YOUR_FILE_PATH");
const sendForSign = new SendForSign();
sendForSign.title = "Agreement";
sendForSign.signers = [documentSigner];
sendForSign.files = [files];
const documentCreated = documentApi.sendDocument(sendForSign);
Replace the API key and file path placeholders with your own values before you run the code. The demo name and email address stand in for your real signer.
Once the request runs, we email the signer a link. They must verify their identity with the signature provider before they can finish signing.
How to sign documents online with QES
Your signer opens the email link, completes their fields and verifies their identity. They then approve the signature in the provider’s app.
Before their first QES, the signer registers once with Evrotrust. They scan an ID and take a selfie in the Evrotrust app, which issues their qualified certificate.
What the signer does on the signing page
- Open the link in the email and accept the Electronic Signature Disclosure Terms.
- Complete the required fields and select Verify.
- Choose Personal ID, Mobile Number or Email to find their Evrotrust account.
- Approve the request in the Evrotrust app, then tap Sign for free.
The signer has 30 minutes to finish in the app. After that the session ends and they start again. Our article on how to sign a QES document walks through each step.
How do you track and download signed QES documents?
Set up webhooks so your app hears when a document is signed. Then download the signed file and its audit trail through the API.
The audit trail always downloads as a separate file for QES documents. The same goes for attachments.
What rules apply to QES signers and files?
QES depends on a clear signing order and a few file limits. Plan your request around them before you send.
Signer rules
- Give each signer a place of their own in the signing order.
- Turn on QES for one signer, the last signer, or every signer.
- Leave QES off for reviewers and group signers.
- Expect only the first QES signer to get every field type.
Other QES signers get a shorter list of fields, such as Signature, Editable Date and Date Signed.
Document limits
- Keep all files in one document to 30 megabytes (MB) or less.
- Skip collaborative editing on QES documents.
- Expect Combine Audit Trail and Combine Attachments to have no effect.
Which plan do you need, and what does QES cost?
QES through the API needs the Enterprise API plan, which includes live API access and webhooks. Each signing attempt costs $3, whether it succeeds or fails, on top of the plan price.
Live API access comes with the Enterprise API plan, from $30 a month with 40 envelopes, billed yearly. Each extra envelope costs $0.75. Prices are in USD, as of November 2026.
A contract with two QES signers costs $6 in QES charges when both sign on the first try. You can build and test your integration first with a free API sandbox account.
Where do you go from here?
Try the request in a sandbox, then talk to us about QES for your live documents.
- Create a free API sandbox account and send a test document.
- Book a demo to see QES signing with our team.
- Browse the eSignature API page, or open a support ticket with questions.
Frequently asked questions
What is a qualified electronic signature (QES)?
A QES is the strictest level of electronic signature under EU law. A qualified trust service provider checks the signer's identity and issues a qualified certificate before the signature is made.
Is a QES legally binding in the EU?
Yes, when it is created with a qualified certificate from a qualified trust service provider. Article 25 of the electronic identification, authentication and trust services (eIDAS) regulation gives a QES the same legal effect as a handwritten signature in every EU member state.
How do I turn on QES for a document sent through the API?
Turn QES on in your Business Profile settings first. Then set EnableQes to true on the signer in your send request, and that signer signs with a QES.
How much does QES cost in BoldSign?
QES costs $3 per signing attempt, whether the attempt succeeds or fails. The charge comes on top of your plan price, as of November 2026.
Does my signer need an Evrotrust account?
Your signer needs an account with the signature provider they choose, and Evrotrust is the default. They register once in the Evrotrust app by scanning an ID and taking a selfie.
What should I look for in e-signature API providers for QES?
Look for a provider that works with qualified trust service providers recognised under eIDAS. Check that you can turn QES on per signer in a request, download an audit trail and see a clear price per signature.
Can more than one signer use QES on the same document?
Yes, when each signer has a place of their own in the signing order. Reviewers and group signers cannot use QES.
How large can a QES document be?
All files in a QES document together can be up to 30 megabytes. Split larger packs into separate documents before you send them.