---
title: "Add Hyperlinks to Digital Contracts Using BoldSign API"
description: "Learn how adding hyperlinks with BoldSign eSignatureAPI enhances workflows. Discover hyperlink types, use cases, and code samples for simple document signing."
url: "https://boldsign.com/blogs/adding-hyperlinks-boldsign-api/"
---

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

# Make Digital Contracts Smarter by Adding Hyperlinks with BoldSign API

[Evans Omondi Otieno](https://boldsign.com/author/evans-omondi-otieno/) November 26, 2025 Updated April 20, 2026 8 min read

Digital contracts are often burdened by excess text, unclear references, and lengthy review cycles. Adding hyperlinks directly to eSignature documents addresses these issues by providing signers with immediate access to supporting information. With the BoldSign [eSignature API](https://boldsign.com/esignature-api.md), organizations can incorporate hyperlinks into contracts programmatically, making the signing experience clearer, faster, and more efficient.

## Why use hyperlinks in documents?

Clickable links can enhance your documents by:

### 1. Immediate access to missing information

Signers often pause because they do not understand a clause, term, or policy.\
Hyperlinks let them open the reference instantly instead of:

- Emailing your team
- Searching your website
- Requesting clarification
- Waiting for a response

This removes delays and keeps the signer in the flow.

### 2. Fewer back-and-forth clarifications

When key documents (privacy policy, fee schedules, disclosures) are linked, signers do not need to ask for attachments or updated versions. Less back-and-forth = faster sign-off.

### 3. Real-time guidance during decisions

Links to help articles, FAQs, or instructions allow signers to self-resolve questions on the spot. This prevents confusion at critical steps, increasing the likelihood they will finish the process without dropping off.

### 4. Reduced cognitive load

Hyperlinks replace long explanations in the contract. Signers can **skim the contract** and open details only if needed, making the review experience lighter and faster.

### 5. Higher trust and clarity

When sensitive terms link to authoritative pages (legal policies, regulatory documents), signers feel more confident. Higher trust increases the probability that they will complete the signing process.

### 6. Updated information without reissuing documents

Linked content stays current even if policies change. No need to resend revised PDFs — signers access the latest version immediately.

## Supported hyperlink types

You can use the **FormField** object with the **`fieldType`** set to **Hyperlink** to create the following types of links:

- **Webpage link**

  - **Format:** The URL should start with either http or https, e.g., [https://www.google.com](https://www.google.com/).
  - **Behavior**: Opens the specified webpage in the signer’s browser.
  - **Use case**: Link to product pages, documentation, or external forms.

- **Email link**

  - **Format**: mailto:“<example@gmail.com>”.
  - **Behavior**: Opens the signer’s default email client to compose a message.
  - **Use case**: Provide a contact email for support or inquiries.

- **Phone link**

  - **Format**: tel: +{phone number with country code}.
  - **Behavior**: Initiates a call using the signer’s default phone application.
  - **Use case**: Offer direct phone support or contact options.

## Step-by-step guide: sending a document to the signer with a hyperlink form field

When sending a document to a signer, set the `fieldType` to Hyperlink.

You must also:

- Provide the  `hyperlinkText` (text to display) along with the actual hyperlink value within the `value` property.
- Ensure that a hyperlink field is not used alone. Because hyperlink and label fields are considered common fields, at least one additional form field (other than dateSigned or a label) must be assigned along with them for all signers in the document.

> 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](https://support.boldsign.com/kb/article/20082/use-the-boldsign-production-api-key) in BoldSign. Use the API key generation [guide](https://developers.boldsign.com/authentication/api-key/?region=us) for detailed steps.

### Example code for sending signature requests with hyperlinks

```
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 'Title=Sample Document' \
  -F 'Signers={
  "name": "hanky",
  "emailAddress": "hankyWhites@gmail.com",
  "signerType": "Signer",
  "formFields": [
    {
      "id": "HyperLink",
      "fieldType": "Hyperlink",
      "pageNumber": 1,
      "bounds": {
        "x": 50,
        "y": 600,
        "width": 150,
        "height": 50
      },
      "hyperlinkText": "Employee Handbook",
      "value": "https://www.google.com"
    },
    {
      "id": "HyperLink_2",
      "fieldType": "Hyperlink",
      "pageNumber": 2,
      "bounds": {
        "x": 50,
        "y": 600,
        "width": 150,
        "height": 50
      },
      "hyperlinkText": "Company email address",
      "value": "mailto:{emailAddress}"
    }
  ]
}' \
  -F 'Files=@{your file}'
```

```
using BoldSign.Api;
using BoldSign.Model;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Initialize API client
        var apiClient = new ApiClient("https://api.boldsign.com", "Your API key");
        var documentClient = new DocumentClient(apiClient);

        // File to upload
        var documentFilePath = new DocumentFilePath
        {
            ContentType = "application/pdf",
            FilePath = "C:\\path\\to\\your\\file.pdf" // replace with actual file path
        };

        var filesToUpload = new List
        {
            documentFilePath
        };

        // Hyperlink field (web link)
        var hyperlinkField = new FormField(
            id: "Hyperlink",
            isRequired: true,
            type: FieldType.Hyperlink,
            pageNumber: 1,
            hyperlinkText: "Employee Handbook", // text to display
            value: "https://www.google.com",     // actual hyperlink value
            bounds: new Rectangle(400, 200, 125, 25)
        );

        // Hyperlink field (email link)
        var hyperlinkMailField = new FormField(
            id: "Hyperlink_2",
            isRequired: true,
            type: FieldType.Hyperlink,
            pageNumber: 2,
            hyperlinkText: "Company email address", // text to display
            value: "mailto:someone@company.com",     // must start with mailto:
            bounds: new Rectangle(400, 200, 125, 25)
        );

        // Collect all form fields
        var formFieldCollections = new List
        {
            hyperlinkField,
            hyperlinkMailField
        };

        // Define signer
        var signer = new DocumentSigner(
            signerName: "David",
            signerEmail: "david@cubeflakes.com",
            signerType: SignerType.Signer,
            formFields: formFieldCollections
        );

        var documentSigners = new List
        {
            signer
        };

        // Send document for signing
        var sendForSign = new SendForSign
        {
            Signers = documentSigners,
            Title = "Sample Document",
            Files = filesToUpload
        };

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

```
import boldsign

# Configure API client
configuration = boldsign.Configuration(api_key="Your API Key")

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

    # Define form fields
    form_fields = [
        boldsign.FormField(
            id="HyperLink",
            fieldType="Hyperlink",
            pageNumber=1,
            bounds=boldsign.Rectangle(x=50, y=700, width=150, height=50),
            hyperlinkText="Employee Handbook",  # text to display
            value="https://www.google.com",  # actual hyperlink value
        ),
        boldsign.FormField(
            id="HyperLink_2",
            fieldType="Hyperlink",
            pageNumber=1,
            bounds=boldsign.Rectangle(x=50, y=600, width=150, height=50),
            hyperlinkText="Company email address",  # text to display
            value="mailto:someone@company.com",  # must start with mailto:
        ),
    ]

    # Define signer
    document_signer = boldsign.DocumentSigner(
        name="David",
        emailAddress="david@cubeflakes.com",
        signerType="Signer",
        formFields=form_fields,
    )

    # Prepare document for signing
    send_for_sign = boldsign.SendForSign(
        title="Test",
        files=[r"C:\path\to\YourFile.pdf"],  # replace with actual file path
        signers=[document_signer],
    )

    # Send document
    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
};

// Configure API client
$config = new Configuration();
$config->setApiKey('Your API Key');

$documentApi = new DocumentApi($config);

// Define form fields
$formFields = [];

// Hyperlink field (web link)
$formField = new FormField();
$formField->setId("HyperLink");
$formField->setFieldType("Hyperlink");
$formField->setPageNumber(1);
$formField->setBounds(new Rectangle(['x' => 50, 'y' => 700, 'width' => 150, 'height' => 50]));
$formField->setHyperlinkText("Employee Handbook"); // text to display
$formField->setValue("https://www.google.com");    // actual hyperlink value
$formFields[] = $formField;

// Hyperlink field (email link)
$formField = new FormField();
$formField->setId("HyperLink_2");
$formField->setFieldType("Hyperlink");
$formField->setPageNumber(1);
$formField->setBounds(new Rectangle(['x' => 50, 'y' => 800, 'width' => 150, 'height' => 50]));
$formField->setHyperlinkText("Company email address"); // text to display
$formField->setValue("mailto:someone@company.com");    // must start with mailto:
$formFields[] = $formField;

// Define signer
$documentSigner = new DocumentSigner();
$documentSigner->setName("David");
$documentSigner->setEmailAddress("david@cubeflakes.com");
$documentSigner->setSignerType("Signer");
$documentSigner->setFormFields($formFields);

// Prepare document for signing
$sendForSign = new SendForSign();
$pdfFilePath = 'C:/path/to/YourFile.pdf'; // replace with actual file path
$sendForSign->setFiles([$pdfFilePath]);
$sendForSign->setSigners([$documentSigner]);
$sendForSign->setTitle('Non Disclosure Agreement');

// Send document
$documentCreated = $documentApi->sendDocument($sendForSign);
```

```
import com.boldsign.ApiClient;
import com.boldsign.Configuration;
import com.boldsign.api.DocumentApi;
import com.boldsign.model.*;
import java.io.File;
import java.util.Arrays;

public class SendDocumentExample {
    public static void main(String[] args) {
        try {
            // Initialize API client
            ApiClient client = Configuration.getDefaultApiClient();
            client.setApiKey("Your API Key");

            DocumentApi documentApi = new DocumentApi(client);

            // Hyperlink field (web link)
            FormField hyperlink1 = new FormField();
            hyperlink1.setId("HyperLink");
            hyperlink1.setFieldType(FormField.FieldTypeEnum.HYPERLINK);
            hyperlink1.setPageNumber(1);
            hyperlink1.setBounds(new Rectangle().x(50f).y(900f).width(150f).height(50f));
            hyperlink1.setHyperlinkText("Employee Handbook"); // text to display
            hyperlink1.setValue("https://www.google.com"); // actual hyperlink value

            // Hyperlink field (email link)
            FormField hyperlink2 = new FormField();
            hyperlink2.setId("HyperLink_2");
            hyperlink2.setFieldType(FormField.FieldTypeEnum.HYPERLINK);
            hyperlink2.setPageNumber(1);
            hyperlink2.setBounds(new Rectangle().x(50f).y(800f).width(150f).height(50f));
            hyperlink2.setHyperlinkText("Company email address"); // text to display
            hyperlink2.setValue("mailto:someone@company.com"); // must start with mailto:

            // Define signer
            DocumentSigner signer = new DocumentSigner();
            signer.setName("David");
            signer.setEmailAddress("david@cubeflakes.com");
            signer.setSignerType(DocumentSigner.SignerTypeEnum.SIGNER);
            signer.setFormFields(Arrays.asList(hyperlink1, hyperlink2));

            // Prepare document for signing
            SendForSign sendForSign = new SendForSign();
            File file = new File("C:/path/to/YourFile.pdf"); // replace with actual file path
            sendForSign.setFiles(Arrays.asList(file));
            sendForSign.setSigners(Arrays.asList(signer));
            sendForSign.setTitle("Non Disclosure Agreement");

            // Send document
            DocumentCreated documentCreated = documentApi.sendDocument(sendForSign);
            System.out.println("Document created with ID: " + documentCreated.getDocumentId());

        } catch (ApiException e) {
            System.err.println("Error occurred: " + e.getMessage());
        }
    }
}
```

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

async function sendDocument() {
  // Initialize API client
  const documentApi = new DocumentApi();
  documentApi.setApiKey("Your API Key");

  // Define form fields
  const formFields = [
    {
      id: "HyperLink",
      fieldType: "Hyperlink",
      pageNumber: 1,
      bounds: { x: 50, y: 600, width: 150, height: 50 },
      hyperlinkText: "Employee Handbook", // text to display
      value: "https://www.google.com", // actual hyperlink value
    },
    {
      id: "HyperLink_2",
      fieldType: "Hyperlink",
      pageNumber: 1,
      bounds: { x: 50, y: 700, width: 150, height: 50 },
      hyperlinkText: "Company email address", // text to display
      value: "mailto:someone@company.com", // must start with mailto:
    },
  ];

  // Define signer
  const documentSigner = new DocumentSigner();
  documentSigner.name = "David";
  documentSigner.emailAddress = "stacywilson@cubeflakes.com";
  documentSigner.signerType = DocumentSigner.SignerTypeEnum.Signer;
  documentSigner.formFields = formFields;

  // File to upload
  const fileStream = fs.createReadStream("C:/path/to/NonDisclosureAgreement.pdf"); // replace with actual file path

  // Prepare document for signing
  const sendForSign = new SendForSign();
  sendForSign.title = "Agreement";
  sendForSign.signers = [documentSigner];
  sendForSign.files = [fileStream];

  try {
    // Send document
    const documentCreated = await documentApi.sendDocument(sendForSign);
    console.log("Document created with ID:", documentCreated.documentId);
  } catch (error) {
    console.error("Error occurred:", error.message);
  }
}

// Run
sendDocument();
```

In the previous code examples, make sure to set values for the following fields:

- **`hyperlinkText`** : The text to display for the hyperlink.
- **`value`** : The actual value for the hyperlink, e.g., a valid URL, email address, or phone number.

Once the code is executed, the document will be created with a hyperlink form field, and an email will be sent to the signer for signing.

Here is a sample display of a signing page featuring hyperlinks:

![Hyperlink](https://boldsign.com/images/blogs/adding-hyperlinks-boldsign-api/hyperlink.svg)

Refer to this [documentation](https://developers.boldsign.com/how-to-guides/how-to-set-hyperlink-form-fields/?region=us) on adding hyperlinks.

## Business Impact

Organizations benefit from:

- Shorter review cycles
- Fewer clarification requests
- Faster decision-making during signing
- Higher completion rates across workflows
- Reduced friction for customers, partners, and employees

With minimal implementation effort, hyperlinks transform a static PDF into a dynamic, context-rich digital contract.

## Best practices for hyperlinks

- **Keep hyperlink text descriptive**\
  Example: Use “View terms of service” instead of “Click here.”
- **Avoid overloading documents with too many links**\
  Too many links can confuse signers.
- **Test links on several devices**\
  Ensure they work on desktop and mobile form factors.
- **Use secure URLs (HTTPS)**\
  Keep your contacts safe and prevent security warnings.

## Conclusion

Clickable hyperlinks are a simple yet powerful way to enrich your documents and streamline communication. With BoldSign’s API, integrating them into your signing workflow is smooth and efficient.

Ready to enhance your documents with clickable hyperlinks? Create a [free sandbox account](https://account.boldsign.com/signup?planId=1076\&utm_source=boldsignblogs\&utm_medium=redirect\&utm_campaign=boldsign) and explore the [BoldSign API documentation](https://developers.boldsign.com/api-overview/getting-started/?region=us) to start optimizing your workflows today.

We’d love to hear from you! Share your feedback or questions in the comments below. Need assistance? Reach out to our support team or schedule a personalized demo—we’re here to help.

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)

## Frequently asked questions

### What types of content can I link inside an eSignature document?

You can link to Terms of Service, Privacy Policies, compliance or regulatory documents, product pages, support articles, FAQs, or any external URL that provides additional context or instructions.

### Will hyperlinks increase signer trust?

Providing direct access to authoritative information—such as policies, legal references, or service details—helps build transparency and confidence, leading to more informed and decisive signers.

### Do I need a specific API plan or setting enabled to use hyperlinks?

No special plan is required beyond the ability to create documents or templates with form fields. Hyperlink fields are treated like any other field type.

### Are hyperlinks supported in all eSignature platforms via API?

Hyperlink support through APIs is a feature offered only by selected eSignature platforms. BoldSign supports this feature via its API, allowing you to add clickable hyperlinks to documents for sharing terms, help pages, or other resources during the signing process.

### Can I add multiple hyperlinks in a single document using an API?

Yes, you can add multiple hyperlinks to a single document using BoldSign’s API. Each hyperlink is added as a separate hyperlink form field, allowing you to define the link text and URL when preparing the document for signing.

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