---
title: "Sender Identity API: Send eSignatures on Behalf | BoldSign"
description: "Sender identity in BoldSign lets your app send eSignature requests on behalf of a colleague or client after they approve, with no shared logins."
url: "https://boldsign.com/sender-identity-send-esignatures-on-behalf/"
---

Sender identities

# Send eSignature requests on behalf of another user

With BoldSign sender identities, your app sends documents as a colleague or client after they approve. Nobody shares a login.

[Create free API sandbox](https://account.boldsign.com/signup?planId=1076)[Book a walkthrough](https://boldsign.com/request-demo.md)

- The identity owner approves first
- Signers see the owner as the sender

\+ Create New Dashboard Documents My Documents Behalf Documents Templates

Search documentsSend

TitleOn behalf ofStatus

Service agreementTo DavidLuther CooperWaiting

Example with sample data: the Behalf Documents list, where a service agreement sent on behalf of Luther Cooper is waiting for David

Trusted by 100,000+ organizations worldwide

![Samsonite](https://boldsign.com/assets/landing/trustbar/samsonite.svg)

![Ryanair](https://boldsign.com/assets/landing/trustbar/ryanair.svg)

![Hyatt](https://boldsign.com/assets/landing/trustbar/hyatt.svg)

![Sony](https://boldsign.com/assets/landing/trustbar/sony.svg)

![Crumbl Cookies](https://boldsign.com/assets/landing/trustbar/crumbl.svg)

![Payroc](https://boldsign.com/assets/landing/trustbar/payroc.svg)

![Cost Plus](https://boldsign.com/assets/landing/trustbar/costplus.svg)

Use cases

## When do teams send signature requests on behalf of others?

BoldSign sender identities suit teams where one person prepares documents and another is the face of them.

- ### Executive assistants

  Send NDAs, offer letters, and approvals as the executive, and track every reply.

  [See the 3 setup steps](#bs-sender-id-steps)

- ### Sales operations

  Send quotes and order forms as the assigned rep, so customers see a name they know.

  [See what you can do](#bs-sender-id-actions)

- ### Platforms and apps

  Your software drives the signing flow, while each business user stays the official sender.

  [See the code](#bs-sender-id-dev)

Why BoldSign

## Why choose BoldSign for sending on behalf of others

With BoldSign, delegation stays approved, visible, and easy to undo.

- ### Approval before any send

  Nothing goes out in the owner’s name until they approve your request.

- ### Private to the person who set it up

  Each sender identity belongs to the user who created it. Teammates and admins cannot see or use it.

- ### Access the owner can revoke

  The identity owner can withdraw your access at any time.

- ### A full audit trail

  Every action on a document is logged, so you can show who did what.

- ### Free help on every plan

  Help by chat, email, or support ticket, free on every plan.

Sending as someone else

## How can your app send eSignature requests as someone else?

With the BoldSign sender identity feature, you send and manage signature requests as another person, once they approve. You add their name and email, and they approve by email. Your API calls then carry their address, and signers see them as the sender. See [the three setup steps](#bs-sender-id-steps) below.

Works in: the BoldSign API. Create identities in the API or the web app.

Why it matters

## Why sending signature requests for someone else gets messy

- ### Shared logins

  An assistant or an app signs in with someone else’s password. Nobody can tell who really sent what. With BoldSign, the owner approves your access instead.

  [See how approval works](#bs-sender-id-steps)

- ### The wrong sender name

  Signers ignore a request from an address they do not know. With BoldSign, the request shows the identity owner as the sender.

  [See what signers see](#bs-sender-id-actions)

- ### No way to take access back

  Once a password is shared, access is hard to undo. With BoldSign, the owner keeps a switch to end your access.

  [See the controls](#bs-sender-id-control)

How it works

## How do you send documents on behalf of another user?

With BoldSign, you set up sending on behalf of someone in 3 steps.

1. ### Create the sender identity

   Add the person’s name and email through the API or the web app.

   1const senderIdentityRequest = new CreateSenderIdentityRequest();2senderIdentityRequest.name = "Luther Cooper";3senderIdentityRequest.email = "luthercooper\@cubeflakes.com";4senderIdentitiesApi.createSenderIdentities(senderIdentityRequest);

   Code excerpt: the name and email of the sender identity, Luther Cooper, are highlighted

2. ### The owner approves

   They get an email and approve your request. From then on, you act for them.

   Approve a sender identity request

   Daniel Ortiz asks to send documents on your behalf.

   ApproveReject

   Sample approval email: Daniel Ortiz asks Luther Cooper to approve sending documents on his behalf, with Approve and Reject buttons

3. ### Send on their behalf

   Put their email in the `OnBehalfOf` property of your send request.

   1sendForSign.title = "SDK Document Test case";2sendForSign.signers = \[documentSigner];3sendForSign.onBehalfOf = "luthercooper\@cubeflakes.com";4const documentCreated = documentApi.sendDocument(sendForSign);

   Code excerpt: the onBehalfOf line with Luther Cooper’s email is highlighted

On behalf actions

## What you can do as the sender identity

After approval, BoldSign lets you run the whole signing request as the owner, not only the send.

- ### Send and remind

  Send documents, then send reminders as the owner.

- ### Revoke and change access codes

  Revoke a request or change its access code without the owner’s login.

- ### Download audit trails

  Download the audit log for every document you sent for them.

- ### The owner stays informed

  The owner gets an email when a document is viewed, signed, or completed. You choose which events notify them.

- ### Your brand on the approval page

  Show your logo on the approval email and page, in the owner’s language.

Security

## How are documents sent on behalf of others kept secure?

BoldSign encrypts every document twice with AES-256. Its security controls are independently audited for SOC 2 Type 2. Each standard is listed on your account’s Compliance page, shown below.

Settings

Compliance

BoldSign meets global security and compliance standards to protect your documents and data. Manage the settings below to align with your organization’s requirements.

- ![US flag](https://boldsign.com/assets/landing/compliance/residency-de93bd.svg) Data Residency

  Active (US - Global)

  Your documents and signer data are securely stored in your selected region to meet data sovereignty and local regulatory requirements.

  [View Data Residency Policy](https://boldsign.com/security-policy.md)

- ![HIPAA logo](https://boldsign.com/assets/landing/compliance/hipaa-c34e9b.png) HIPAA Compliance

  Enabled

  Enable HIPAA mode to protect PHI using administrative, technical, and physical safeguards aligned with HIPAA regulations.

  [View Details](https://boldsign.com/hipaa-overview.md)

- ![PCI DSS logo](https://boldsign.com/assets/landing/compliance/pci-960f14.png) PCI DSS

  Compliant

  Payments are securely processed through Stripe, a PCI DSS Level 1-certified provider, ensuring the safe handling and encryption of all payment data.

  [View PCI DSS Policy](https://boldsign.com/security-policy.md)

- ![CCPA logo](https://boldsign.com/assets/landing/compliance/ccpa-e62333.png) CCPA & CPRA

  Compliant

  Ensures compliance with California privacy laws, giving residents transparency and control over their personal data, including rights to access, delete, and opt out.

  [View Privacy Policy](https://boldsign.com/privacy-policy.md)

- ![AICPA SOC logo](https://boldsign.com/assets/landing/compliance/soc2-b31494.png) SOC 2 Type II

  Compliant

  BoldSign has successfully completed a SOC 2 Type II audit, validating our controls for security, availability, confidentiality, and data integrity.

  [Request SOC 2](https://boldsign.com/soc2-overview.md)

- ![US flag](https://boldsign.com/assets/landing/compliance/esign-de93bd.svg) UETA & ESIGN

  Compliant

  BoldSign ensures that all e-signatures are legally binding and compliant with the U.S. ESIGN Act and the Uniform Electronic Transactions Act (UETA).

  [View UETA & ESIGN Policy](https://boldsign.com/ueta-and-esign-act-compliance.md)

- ![EU flag](https://boldsign.com/assets/landing/compliance/eidas-ses-677fe1.svg) eIDAS (SES)

  Compliant

  BoldSign complies with the EU eIDAS Regulation (910/2014) and supports Simple Electronic Signatures (SES) by default.

  [View SES Policy](https://boldsign.com/simple-electronic-signature-compliance.md)

- ![EU flag](https://boldsign.com/assets/landing/compliance/eidas-qes-677fe1.svg) eIDAS (QES)

  Enabled

  Enable Qualified Electronic Signatures (QES) for contracts requiring the highest legal assurance under eIDAS.

  [View QES Policy](https://boldsign.com/qes-overview.md)

The compliance panel in your BoldSign account.

What it costs

## Limits and costs to know before you send on behalf of others with BoldSign

BoldSign sends on behalf of others through the API only. The web app lists those documents but does not send them.

Prices are in USD.

- $30 Enterprise API plan, a month Includes 40 envelopes. Prices are in USD.
- $0.75 per envelope after 40 Billed as you go.

[Create free API sandbox](https://account.boldsign.com/signup?planId=1076)[See API pricing](https://boldsign.com/electronic-signature-pricing/?plan=api)

Good to know

## Before you set up sender identities

- 1 account per identity email An email cannot be a sender identity in two accounts.

* You cannot create a sender identity for your own email.

For developers

## Code to send eSignature requests on behalf of another user

BoldSign SDKs cover cURL, .NET, Python, PHP, Java, and Node. Each sample below comes from the developer docs.

### Step 1: create a sender identity

**cURL**

cURL

```
curl -X 'POST' \
  'https://api.boldsign.com/v1/senderIdentities/create' \
  -H 'accept: */*' \
  -H 'X-API-KEY: {your API key}' \
  -H 'Content-Type: application/json;odata.metadata=minimal;odata.streaming=true' \
  -d '{
  "Name": "Luther Cooper",
  "Email": "luthercooper@cubeflakes.com",
  "RedirectUrl": "",
  "BrandId": "c94d34e9-8f1f-4ab1-926d-daa32095a851",
  "NotificationSettings": {
    "Viewed": true,
    "Sent": false,
    "DeliveryFailedFor": true,
    "Declined": true,
    "Revoked": true,
    "Reassigned": true,
    "Completed": true,
    "Signed": true,
    "Expired": true,
    "AuthenticationFailed": true,
    "Reminders": true,
    "AttachSignedDocument": false
  },
  "MetaData": {
    "TenantId": "xxxxx070-xxxx-xxxx-xxxx-757xxxxxxxxx",
    "AccountPlan": "Free"
  },
  "Locale": "EN"
}'
```

**.NET**

.NET

```
var apiClient = new ApiClient("https://api.boldsign.com", "Your_API_Key");
var senderIdentityClient = new SenderIdentityClient(apiClient);
var senderIdentityRequest = new SenderIdentityRequest("Luther Cooper", "luthercooper@cubeflakes.com", null);
senderIdentityRequest.MetaData = new Dictionary<string, string>()
{
  ["tenantId"] = "xxxxx070-xxxx-xxxx-xxxx-757xxxxxxxxx",
  ["accountPlan"] = "Free"
};
var senderIdentityCreated = senderIdentityClient.CreateSenderIdentity(senderIdentityRequest);
```

**Python**

Python

```
import boldsign
configuration = boldsign.Configuration(host = "https://api.boldsign.com", api_key="YOUR_API_KEY")
with boldsign.ApiClient(configuration) as api_client:
  
    sender_identities_api = boldsign.SenderIdentitiesApi(api_client)
    sender_identity_request = boldsign.CreateSenderIdentityRequest(
        name="Luther Cooper",
        email="luthercooper@cubeflakes.com",
    )
  
    sender_identities_api.create_sender_identities(sender_identity_request)
```

**PHP**

PHP

```
<?php require_once "vendor/autoload.php";
use BoldSign\Configuration;
use BoldSign\Api\SenderIdentitiesApi;
use BoldSign\Model\CreateSenderIdentityRequest;
$config = new Configuration();
$config->setHost('https://api.boldsign.com');
$config->setApiKey('YOUR_API_KEY');
$sender_identities_api = new SenderIdentitiesApi($config);
$sender_identity_request = new CreateSenderIdentityRequest();
$sender_identity_request->setName('Luther Cooper');
$sender_identity_request->setEmail('luthercooper@cubeflakes.com');
$sender_identities_api->createSenderIdentities($sender_identity_request);
```

**Java**

Java

```
ApiClient client = Configuration.getDefaultApiClient();
client.setBasePath("https://api.boldsign.com");
client.setApiKey("YOUR_API_KEY");
  
SenderIdentitiesApi senderIdentitiesApi = new SenderIdentitiesApi(client);
CreateSenderIdentityRequest senderIdentityRequest = new CreateSenderIdentityRequest();
senderIdentityRequest.setName("Luther Cooper");
senderIdentityRequest.setEmail("luthercooper@cubeflakes.com");
senderIdentitiesApi.createSenderIdentities(senderIdentityRequest);
```

**Node**

Node

```
import { SenderIdentitiesApi, CreateSenderIdentityRequest } from "boldsign";
const senderIdentitiesApi = new SenderIdentitiesApi("https://api.boldsign.com");
senderIdentitiesApi.setApiKey("YOUR_API_KEY");
const senderIdentityRequest = new CreateSenderIdentityRequest();
senderIdentityRequest.name = "Luther Cooper";
senderIdentityRequest.email = "luthercooper@cubeflakes.com";
senderIdentitiesApi.createSenderIdentities(senderIdentityRequest);
```

### Step 2: the owner approves

No code is needed here. BoldSign emails the owner, and they approve or reject. To send the email again, call the [resend invitation endpoint](https://developers.boldsign.com/sender-identities/resend-invitation/).

### Step 3: send a document on behalf of the owner

**cURL**

cURL

```
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 'DisableExpiryAlert=false' \
     -F 'ReminderSettings.ReminderDays=3' \
     -F 'BrandId=' \
     -F 'ReminderSettings.ReminderCount=5' \
     -F 'EnableReassign=true' \
     -F 'Message=Please sign this.' \
     -F 'Signers={
          "Name": "David",
          "EmailAddress": "david@cubeflakes.com",
          "FormFields": [
            {
              "FieldType": "Signature",
              "PageNumber": 1,
              "Bounds": {
                "X": 100,
                "Y": 100,
                "Width": 100,
                "Height": 50
              },
              "IsRequired": true
            }
          ]
        }' \
      -F 'ExpiryDays=10' \
      -F 'EnablePrintAndSign=false' \
      -F 'AutoDetectFields=false' \
      -F 'OnBehalfOf=luthercooper@cubeflakes.com' \
      -F 'EnableSigningOrder=false' \
      -F 'UseTextTags=false' \
      -F 'SendLinkValidTill=' \
      -F 'Files=@agreement.pdf;type=application/pdf' \
      -F 'Title=Agreement' \
      -F 'HideDocumentId=false' \
      -F 'EnableEmbeddedSigning=false' \
      -F 'ExpiryDateType=Days' \
      -F 'ReminderSettings.EnableAutoReminder=false' \
      -F 'ExpiryValue=60' \
      -F 'DisableEmails=false' \
      -F 'DisableSMS=false'
```

**.NET**

.NET

```
var apiClient = new ApiClient("https://api.boldsign.com", "Your_API_Key");
var documentClient = new DocumentClient(apiClient);
List<FormField> 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)
    },
    Files = new List<IDocumentFile>
    {
        new DocumentFilePath
        {
            ContentType = "application/pdf",
            FilePath = "YOUR_FILE_PATH",
        }
    },
    OnBehalfOf = "luthercooper@cubeflakes.com"
};
var documentCreated = documentClient.SendDocument(documentDetails);
```

**Python**

Python

```
import boldsign
configuration = boldsign.Configuration(host = "https://api.boldsign.com", 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])
    send_for_sign = boldsign.SendForSign(
        title="Agreement",
        files=["YOUR_FILE_PATH"],
        signers=[document_signer],
        onBehalfOf="luthercooper@cubeflakes.com")
    document_created = document_api.send_document(send_for_sign)
```

**PHP**

PHP

```
<?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->setHost('https://api.boldsign.com');
$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]);
$send_for_sign = new SendForSign();
$files = new FileInfo();
$files = 'YOUR_FILE_PATH';
$send_for_sign->setFiles([$files]);
$send_for_sign->setSigners([$document_signer]);
$send_for_sign->setOnBehalfOf('luthercooper@cubeflakes.com');
$send_for_sign->setTitle('Document sdk api');
$document_created = $document_api->sendDocument($send_for_sign);
```

**Java**

Java

```
ApiClient client = Configuration.getDefaultApiClient();
client.setBasePath("https://api.boldsign.com");
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));
SendForSign sendForSign = new SendForSign();
File file = new File("YOUR_FILE_PATH");  
sendForSign.setFiles(Arrays.asList(file));
sendForSign.setSigners(Arrays.asList(signer));
sendForSign.setOnBehalfOf("luthercooper@cubeflakes.com");
sendForSign.setTitle("Document SDK API");
DocumentCreated documentCreated = documentApi.sendDocument(sendForSign);
```

**Node**

Node

```
import { DocumentApi, FormField, Rectangle, DocumentSigner, SendForSign } from "boldsign";
import * as fs from 'fs';
const documentApi = new DocumentApi("https://api.boldsign.com");
documentApi.setApiKey("YOUR_API_KEY");
const bounds = new Rectangle();
bounds.x = 50;
bounds.y = 50;
bounds.width = 200;
bounds.height = 25;
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];
const files = fs.createReadStream("YOUR_FILE_PATH");
const sendForSign = new SendForSign();
sendForSign.title = "SDK Document Test case";
sendForSign.files = [files];
sendForSign.signers = [documentSigner];
sendForSign.onBehalfOf = "luthercooper@cubeflakes.com";
const documentCreated = documentApi.sendDocument(sendForSign);
```

Samples from the [BoldSign developer documentation](https://developers.boldsign.com/sender-identities/create-identity/).

Common questions

## Questions about sending on behalf of another user

### What is a sender identity?

A sender identity is a person you are approved to send signature requests for. You act in their name, and they see every step. Start in the [free API sandbox](https://account.boldsign.com/signup?planId=1076).

### How do I create a sender identity?

Through the API or the web app, enter the owner’s name and email address. They then approve by email, as the [create identity guide](https://developers.boldsign.com/sender-identities/create-identity/) shows.

### What do signers see when I send on someone’s behalf?

Signers see the identity owner’s email as the sender. Notifications follow the owner’s branding and settings, set in the [branding options](https://boldsign.com/electronic-signature-features/branding.md).

### Who can see and use a sender identity?

Only the user who created it. It stays private to that user, so teammates and admins cannot use it. Read more in the [identities reference](https://developers.boldsign.com/sender-identities/list-identities/).

### What happens if I delete a sender identity?

New documents can no longer use it. Past documents keep their original sender details, listed under [behalf documents](https://developers.boldsign.com/documents/behalf-list-documents/).

### Can I test sender identities for free?

Yes. The [API sandbox](https://boldsign.com/electronic-signature-pricing/?plan=api) is free for building and testing. Sandbox documents are watermarked and deleted after 14 days.

### Are documents sent on behalf of others legally binding?

Yes. BoldSign complies with the ESIGN Act, UETA, and eIDAS, so its signatures are secure and legally binding. Read more on [eSignature legality](https://boldsign.com/electronic-signature-legality.md).

Related

## More on building eSignature into your app

BoldSign guides cover the full API, embedded signing, and how sender identities compare with OAuth.

- Page

  ### eSignature API

  Everything the BoldSign API can do.

  [See the page](https://boldsign.com/esignature-api.md)

- Page

  ### Embedded signing

  Let users sign inside your app.

  [See the page](https://boldsign.com/embedded-signatures.md)

- Blog

  ### OAuth or sender identities

  Which one fits your integration.

  [Read the post](https://boldsign.com/blogs/oauth-vs-sender-identities-explained.md)

- Docs

  ### Send document on behalf

  Every property of the send request.

  [Read the docs](https://developers.boldsign.com/documents/send-document-on-behalf/)

Get started

## Send as your colleagues and clients, with their approval

Build and test BoldSign sender identities in the free API sandbox.

[Create free API sandbox](https://account.boldsign.com/signup?planId=1076)[Book a walkthrough](https://boldsign.com/request-demo.md)

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

Last updated: October 17, 2026.
