---
title: "Send eSignature Requests with Your Brand Identity via API"
description: "Customize your eSignature requests with your brand identity using BoldSign's API. Integrate a seamless, branded signing experiences into your workflow."
url: "https://boldsign.com/blogs/send-esignature-requests-with-your-brand-identity-via-api/"
---

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

# Send eSignature Requests with Your Brand Identity via API

[Gopinath Kannusamy](https://boldsign.com/author/gopinath-kannusamy/) September 12, 2024 Updated April 20, 2026 6 min read

Maintaining a consistent brand identity across all customer interactions is essential for businesses. When sending electronic signature requests, ensuring that your brand is prominently displayed in your documents can significantly influence how recipients perceive your business. BoldSign offers a robust [branding](https://boldsign.com/electronic-signature-features/branding.md) feature that allows you to personalize the appearance of your eSignature requests via API.

## Why branding matters

Imagine receiving an email asking for your signature on an important document. Wouldn’t it be reassuring to see the logo and colors of the sender in the email? Branding not only enhances trust, it reflects your company’s professionalism. With BoldSign’s branding feature, you can customize the appearance of signature request emails, including elements like logos, background colors, and button colors. You can also customize additional options such as email colors and signing‑page appearance, sender display name, redirect URL after signing, document time zone for audit trails, and legal terms that signers must accept. See the [branding customization guide](https://boldsign.com/blogs/personalize-your-esignature-requests-with-your-brand-identity.md) for the complete list.

Moreover, BoldSign allows you to create multiple brands within the same account, making it easier to manage branding for different products, departments, or even clients. Branding is reflected in **recipient emails** and on the **signing page**, ensuring a consistent experience across repeated workflows.

## Getting started with branding

### 1. Create a brand

Before applying branding to your documents, you need to create a brand in BoldSign. This can be done either through the web app or programmatically via the API.

### Create a brand in the web app

If you prefer to create a brand directly in the BoldSign web app, just navigate to the branding section and follow the steps to upload your logo, choose your color scheme, and customize the email template. For a detailed walkthrough, refer to [how to send a document with your brand identity](https://support.boldsign.com/kb/article/616/how-to-send-a-document-with-your-brand-identity).

### Create a brand via API

For those who favor automation, you can create a brand using BoldSign’s API. The API allows you to set up your brand’s visual identity by specifying parameters such as logo, primary color, and more. For more details, check out the [Branding section of the API documentation](https://developers.boldsign.com/branding/create-brand/?region=us).

Once your brand is created, BoldSign will generate a unique brand ID that you’ll use to associate the brand with specific documents.

### 2. Apply branding to your documents

Now that you’ve created your brand, it’s time to put it to work. The brand ID generated in the previous step is the key to applying your branding to any document you send for signature.

Let’s say you’ve created a brand for your company, “CubeFlakes,” with a distinct blue and white color scheme and your company logo. You want every document you send for signature to include this branding. When sending a document via API, specify the **BrandId** to reflect this branding.

Here’s how you can do it with different programming languages:

> **Note:** Add **BrandId** to your send request to ensure the document uses your branding.

```
curl -X POST \
  "https://api.boldsign.com/v1/document/send" \
  -H "accept: application/json" \
  -H "X-API-KEY: YOUR_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F 'BrandId=YOUR_BRAND_ID' \
  -F 'Message=' \
  -F 'Signers={
  "name": "Hanky",
  "emailAddress": "hankyWhites@cubeflakes.com",
  "signerType": "Signer",
  "formFields": [
    {
      "id": "signature1",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 50,
        "y": 50,
        "width": 200,
        "height": 25
      },
      "isRequired": true
    }
  ],
  "locale": "EN"
}' \
  -F 'Files=@FILE_PATH;type=application/pdf' \
  -F 'Title=DOCUMENT_TITLE'
```

```
var apiClient = new ApiClient("https://api.boldsign.com", "YOUR_API_KEY");
var documentClient = new DocumentClient(apiClient);

var documentFilePath = new DocumentFilePath
{
    ContentType = "application/pdf",
    FilePath = "FILE_PATH",
};

var filesToUpload = new List<IDocumentFile> { documentFilePath };

var signatureField = new FormField(
    id: "signature1",
    isRequired: true,
    type: FieldType.Signature,
    pageNumber: 1,
    bounds: new Rectangle(x: 50, y: 50, width: 200, height: 25));

var signer = new DocumentSigner(
    signerName: "Hanky",
    signerType: SignerType.Signer,
    signerEmail: "hankyWhites@cubeflakes.com",
    formFields: new List<FormField> { signatureField },
    locale: Locales.EN);

var sendForSign = new SendForSign
{
    Title = "DOCUMENT_TITLE",
    BrandId = "YOUR_BRAND_ID",
    Signers = new List<DocumentSigner> { signer },
    Files = filesToUpload
};

var documentCreated = documentClient.SendDocument(sendForSign);
```

```
import boldsign

configuration = boldsign.Configuration(api_key="YOUR_API_KEY")

with boldsign.ApiClient(configuration) as api_client:
    document_api = boldsign.DocumentApi(api_client)

    signatureField = boldsign.FormField(
        id="signature1",
        fieldType="Signature",
        pageNumber=1,
        bounds=boldsign.Rectangle(x=50, y=50, width=200, height=25),
        isRequired=True,
    )

    signer = boldsign.DocumentSigner(
        name="Hanky",
        emailAddress="hankyWhites@cubeflakes.com",
        signerType="Signer",
        formFields=[signatureField],
        locale="EN",
    )

    send_for_sign = boldsign.SendForSign(
        title="DOCUMENT_TITLE",
        brandId="YOUR_BRAND_ID",
        signers=[signer],
        files=["FILE_PATH"],
    )

    document_created = document_api.send_document(send_for_sign=send_for_sign)
```

```
import { DocumentApi, DocumentSigner, FormField, Rectangle, SendForSign } from "boldsign";
import * as fs from "fs";

async function main() {
  const api = new DocumentApi();
  api.setApiKey("YOUR_API_KEY");

  const rect1 = new Rectangle();
  rect1.x = 50;
  rect1.y = 50;
  rect1.width = 200;
  rect1.height = 25;

  const signatureField = new FormField();
  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
  signatureField.id = "signature1";
  signatureField.pageNumber = 1;
  signatureField.bounds = rect1;
  signatureField.isRequired = true;

  const signer = new DocumentSigner();
  signer.name = "Hanky";
  signer.emailAddress = "hankyWhites@cubeflakes.com";
  signer.signerType = DocumentSigner.SignerTypeEnum.Signer;
  signer.formFields = [signatureField];
  signer.locale = "EN";

  const send = new SendForSign();
  send.title = "DOCUMENT_TITLE";
  send.brandId = "YOUR_BRAND_ID";
  send.signers = [signer];
  send.files = [fs.createReadStream("FILE_PATH")];

  const documentCreated = await api.sendDocument(send);
}

main();
```

```
<?php
require_once "vendor/autoload.php";

$config = new BoldSign\Configuration();
$config->setApiKey('YOUR_API_KEY');

$document_api = new BoldSign\Api\DocumentApi($config);

$bounds1 = new BoldSign\Model\Rectangle();
$bounds1->setX(50);
$bounds1->setY(50);
$bounds1->setWidth(200);
$bounds1->setHeight(25);

$signatureField = new BoldSign\Model\FormField();
$signatureField->setId("signature1");
$signatureField->setFieldType('Signature');
$signatureField->setPageNumber(1);
$signatureField->setBounds($bounds1);
$signatureField->setIsRequired(true);

$signer = new BoldSign\Model\DocumentSigner();
$signer->setName("Hanky");
$signer->setEmailAddress("hankyWhites@cubeflakes.com");
$signer->setSignerType("Signer");
$signer->setFormFields([$signatureField]);
$signer->setLocale("EN");

$send_for_sign = new BoldSign\Model\SendForSign();
$send_for_sign->setTitle('DOCUMENT_TITLE');
$send_for_sign->setBrandId('YOUR_BRAND_ID');
$send_for_sign->setSigners([$signer]);
$send_for_sign->setFiles(['FILE_PATH']);

$documentCreated = $document_api->sendDocument($send_for_sign);
```

```
ApiClient client = Configuration.getDefaultApiClient();
client.setApiKey("YOUR_API_KEY");

DocumentApi api = new DocumentApi(client);

Rectangle rect1 = new Rectangle();
rect1.setX(50f);
rect1.setY(50f);
rect1.setWidth(200f);
rect1.setHeight(25f);

FormField field = new FormField();
field.setId("signature1");
field.setFieldType(FormField.FieldTypeEnum.SIGNATURE);
field.setPageNumber(1);
field.setBounds(rect1);
field.setIsRequired(true);

DocumentSigner signer = new DocumentSigner();
signer.setName("Hanky");
signer.setEmailAddress("hankyWhites@cubeflakes.com");
signer.setSignerType(DocumentSigner.SignerTypeEnum.SIGNER);
signer.setFormFields(Arrays.asList(field));
signer.setLocale(DocumentSigner.LocaleEnum.EN);

SendForSign send = new SendForSign();
send.setBrandId("YOUR_BRAND_ID");
send.setTitle("DOCUMENT_TITLE");
send.setSigners(Arrays.asList(signer));
send.setFiles(Arrays.asList(new File("FILE_PATH")));

DocumentCreated documentCreated = api.sendDocument(send);
```

After running any of the previous code examples, the document sent for signature will carry your branding. The recipient will see your brand’s logo in the email and on the signing page, reinforcing your brand’s presence.

Document sending in BoldSign is asynchronous. The API returns a documentId immediately, while the file may still be processing in the background. Listen for webhook events to confirm whether document processing and sending succeeded or failed.

BoldSign sends either a Sent event on success or SendFailed on failure. When a failure occurs, inspect the error details, correct the request, and retry. See [Available webhook events](https://developers.boldsign.com/webhooks/available-events/) and [Validate and verify webhook events](https://developers.boldsign.com/webhooks/verify-webhook-events/) for implementation and security guidance.

> **Note:** Validate each webhook signature using the X BoldSign Signature header and your endpoint secret.

![Signing page with branding](https://boldsign.com/images/blogs/send-esignature-requests-with-your-brand-identity-via-api/signing-page-with-branding-1.png)

Signing page with branding

## Branding support for templates

Templates also support branding, and you can include a **BrandId** when [creating a template](https://developers.boldsign.com/template/create-template/). When a template is created with a BrandId, all documents sent from that template use the same branding, including the logo, colors, email styling, and signing‑page appearance. This helps ensure that all signature requests generated from the template maintain a consistent, professional branded experience across repeated workflows.

To see how documents are created and used with brand support from template, refer to the [Send Document from Template](https://developers.boldsign.com/documents/send-document-from-template/) guide.

## Conclusion

Customizing your eSignature requests with your brand identity via API is a simple yet effective way to maintain consistency and build trust with your customers. Whether you manage a single brand or multiple, our API gives you the tools you need to make your brand stand out.

By following the steps in this article, you can easily integrate branding into your eSignature workflow, ensuring that every document you send aligns with your company’s image. For more information, check out [BoldSign’s detailed API documentation](https://developers.boldsign.com/branding/create-brand/?region=us).

Start your [30-day BoldSign free trial](https://account.boldsign.com/signup?planId=1018\&utm_source=boldsignblogs\&utm_medium=redirect\&utm_campaign=boldsign) now to take advantage of a powerful, easy-to-use eSignature platform. Please leave a comment below; your thoughts are much appreciated. [Schedule a demo](https://boldsign.com/request-demo.md) or contact our support team via our [support portal](https://support.boldsign.com/support/tickets/create) if you have any questions or would like more information about our services.

Topics [API integration](https://boldsign.com/blogs/tag/api-integration.md)[Branding](https://boldsign.com/blogs/tag/branding.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)

## Gopinath Kannusamy

Gopinath is a passionate software developer with 2 years of experience at BoldSign. He is an avid writer and enjoys sharing his insights on technology and development. In his free time, he enjoys exploring new technologies and learning new things. Connect with him on [LinkedIn](https://www.linkedin.com/in/gopinath-kannusamy-b7b84517a/).

[More posts by Gopinath Kannusamy](https://boldsign.com/author/gopinath-kannusamy/)

## 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*
