---
title: "Send QES-Enabled Documents Easily via BoldSign API"
description: "Send QES-enabled documents using BoldSign API. Achieve eIDAS compliance, protect data with AES encryption, & simplify secure digital signing for your business."
url: "https://boldsign.com/blogs/secure-qes-signing-boldsign-api/"
---

1. [Blog](https://boldsign.com/blogs.md)
2. [API](https://boldsign.com/category/api.md)

# How to Securely Send QES-Enabled Documents with BoldSign API

[Evans Omondi Otieno](https://boldsign.com/author/evans-omondi-otieno/) November 19, 2025 Updated March 25, 2026 5 min read

Ensuring both security and legal validity in e-signature workflows is more critical than ever. One feature that delivers on both fronts is the [Qualified Electronic Signature](https://boldsign.com/qes.md) (QES), the highest level of trust and legal recognition under the EU’s eIDAS regulation.

With the [BoldSign API](https://boldsign.com/esignature-api.md), integrating QES into your document signing process is seamless, secure, and compliant. In this guide, we’ll cover:

- What QES is and why it matters.
- Why BoldSign is a trusted platform for QES.
- How to send QES-enabled signature requests via API.
- How recipients sign QES documents.
- How to track signed documents.
- Key restrictions to keep in mind.

## What is a QES?

A [QES](https://boldsign.com/blogs/qualified-electronic-signature-qes-compliance.md) is an advanced digital signature backed by a qualified digital certificate issued by a Qualified Trust Service Provider (QTSP). Under the eIDAS regulations in the European Union, QES is legally equivalent to a handwritten signature and offers the highest level of security and legal standing.

## Why choose BoldSign for QES?

BoldSign is built to meet global compliance standards and offers robust support for QES. It offers:

- Built-in QES support via trusted QTSPs for certificate issuance and validation.
- Compliance with eIDAS, GDPR, and other international standards.
- Detailed audit trails for every QES transaction.
- AES 256-bit encryption and advanced cryptographic techniques to protect document integrity.

## How to send QES-enabled signature requests via BoldSign API

### Step 1: Enable QES in your BoldSign account.

To use QES, first enable it from your business profile settings. Once activated, you can apply QES to both documents and templates.

QES is billed on a pay-as-you-go basis at $3 per verification attempt.\
For setup instructions, check out our page on [enabling QES in your business profile](https://support.boldsign.com/kb/article/19863/qualified-electronic-signature-qes#enable-qes-in-business-profile).

### Step 2: Send documents with QES enabled.

Use the BoldSign API and set the `EnableQes` property to true in your request payload.

> Refer to the [documentation](https://developers.boldsign.com/sdks/overview/?region=us) to install the SDKs for your application’s technology stack. After installation, generate your API key in BoldSign. Use the API key generation [guide](https://developers.boldsign.com/authentication/api-key/?region=us) for detailed steps.

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": "alexgayle@boldsign.dev",
      "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);

List 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: "David",
            signerType: SignerType.Signer,
            signerEmail: "david@cubeflakes.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="David",
        emailAddress="david@cubeflakes.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("David");
$document_signer->setEmailAddress("david@cubeflakes.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("David");
signer.setEmailAddress("david@cubeflakes.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 = "David";
documentSigner.emailAddress = "david@cubeflakes.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);
```

In the code examples above, make sure to replace the placeholder values for the API key and file path with your actual API key and file path. Additionally, set the `EnableQes` property to true.

Once executed, the document will be sent to the signer with QES verification enabled, requiring them to verify their identity before completing the signing process.

## How to sign a QES document

Recipients will receive an email with a link to sign the document. To complete the process, they must have an active Evrotrust account. They can sign by clicking the email link and logging into their BoldSign account.

For detailed steps, refer to our article on [how to sign a QES document](https://support.boldsign.com/kb/article/20202/sign-a-qes-document).

## Track and retrieve signed documents

Use webhooks to monitor document status and download signed files and audit trails.

Helpful guides:

- [Setting up a webhook](https://developers.boldsign.com/webhooks/setting-webhook/?region=us)
- [Download document](https://developers.boldsign.com/documents/download-document/?region=us)
- [Download audit trail](https://developers.boldsign.com/documents/download-audit-trail/?region=us)

## QES usage restrictions

Keep these limitations in mind when using QES:

### Signer rules

- Signing order must be enabled for multiple signers.
- QES must be enabled for either all signers or only the last signer.
- Each signer must have a unique signing order.
- QES is not available for self-signing, reviewers, or group signers.

### Feature limitations

- The maximum combined file size is 30 MB.
- Collaborative fields and configure fields are not supported.
- Combine Audit Trail and Combine Attachments options are disabled.
- Only the first signer can access all field types; others are limited to mandatory signature fields.

## Conclusion

With BoldSign’s QES integration, organizations can confidently meet the highest standards of digital signing, ensuring both legal compliance and data security.

**Ready to try it out?**\
Sign up for a [free sandbox account](https://account.boldsign.com/signup?planId=1076) and explore [BoldSign’s powerful features](https://boldsign.com/electronic-signature-features.md).

We’d love to hear your thoughts! Drop a comment below or reach out via our [support portal](https://support.boldsign.com/support/tickets/create). Need a personalized walkthrough? Schedule a [demo](https://boldsign.com/request-demo.md) with our team today!

Topics [API integration](https://boldsign.com/blogs/tag/api-integration.md)

## Sign documents 3x faster

Send, sign and manage documents securely and efficiently.

[Try it today](https://account.boldsign.com/signup?planId=1018\&utm_source=boldsignblogs\&utm_medium=redirect\&utm_campaign=boldsign)

## Evans Omondi Otieno

Evans Omondi Otieno is a customer support representative and writer at BoldSign, specializing in creating clear, insightful content to help users navigate eSignature solutions. As a blog author, Evans writes well-researched articles that simplify technical concepts, helping businesses and professionals understand how to use BoldSign effectively. With expertise in technical support and content creation, he ensures users have a seamless experience and gain valuable knowledge from his articles.

[More posts by Evans Omondi Otieno](https://boldsign.com/author/evans-omondi-otieno/)

## Related posts

- [API](https://boldsign.com/category/api.md) September 29, 2026 10 min read

  ## [How to Migrate from Docusign Without Losing Templates or Workflow Continuity](https://boldsign.com/blogs/migrate-from-docusign.md)

  Learn how to migrate from Docusign while protecting templates, signed records, and active workflows. Explore key risks, a practical checklist, and next steps.

- [API](https://boldsign.com/category/api.md) September 25, 2026 10 min read

  ## [Build vs Buy an eSignature API: What Should You Choose?](https://boldsign.com/blogs/build-vs-buy-esignature-api-guide.md)

  Compare the real cost, compliance risk, launch speed, and maintenance burden of building vs buying an eSignature API before you commit.

- [API](https://boldsign.com/category/api.md) September 22, 2026 9 min read

  ## [What Are the Common Challenges When Using Signature APIs in Software Development](https://boldsign.com/blogs/common-signature-api-challenges.md)

  Explore the common challenges developers face with a Signature API, from authentication issues to PDF rendering, webhooks, templates, and rate limits.

Get started

## Sign up for your free trial today!

[Start free trial](https://account.boldsign.com/signup?planId=1018)

- 30-day free trial
- No credit card required

*Picture: A completed employment contract: signed by John Doe on 11/03/2026, all parties have signed*
