How to Create Templates with BoldSign API

If you frequently need to send the same contracts to different people for signing, templates can help you save time. Once you create a template, you can send contracts in less than a minute using the template.

Below are examples of how to create a template in various programming languages:

Code snippet

curl -X 'POST' \ 'https://api.boldsign.com/v1/template/create' \
  -H 'accept: application/json' \
  -H 'X-API-KEY: {your API key}' \
  -H 'Content-Type: multipart/form-data' \
  -F 'DocumentMessage=document message for signers' \
  -F 'Files=@{your file};type=application/pdf' \
  -F 'Title=title of the template' \
  -F 'AllowMessageEditing=true' \
  -F 'Description=testingDescription' \
  -F 'DocumentTitle=title of the document' \
  -F 'Roles={
  "name": "Manager",
  "index": 1,
  "defaultSignerName": "Alex Gayle",
  "defaultSignerEmail": "[email protected]",
  "signerOrder": 1,
  "signerType": "Signer",
  "formFields": [
    {
      "id": "sign_id",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 50,
        "y": 100,
        "width": 100,
        "height": 60
      },
      "isRequired": true
    }
  ]
}'

var apiClient = new ApiClient("https://api.boldsign.com", "API-KEY");
var templateClient = new TemplateClient(apiClient);
var documentFilePath = new DocumentFilePath
{
    ContentType = "application/pdf",

    FilePath = "{file path}",
};

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

var signatureField = new FormField(
    id: "sign_id",
    type: Type.Signature,
    pageNumber: 1,
    bounds: new Rectangle(x: 50, y: 50, width: 200, height: 30));

var formFieldsCollections = new List<FormField>
{
    signatureField,
};

var templateRole = new TemplateRole(
    roleIndex: 1,
    name: "Manager",
    defaultSignerName: "Alex Gayle",
    defaultSignerEmail: "[email protected]",
    signerOrder: 1,
    signerType: SignerType.Signer,
    formFields: formFieldsCollections,
    locale: Locales.EN);

var roles = new List<TemplateRole>
{
    templateRole,
};

var templateRequest = new CreateTemplateRequest()
{
    Title = "title of the template",
    DocumentMessage = "document message for signers",
    Files = filesToUpload,
    Description = "testingDescription",
    DocumentTitle = "title of the document",
    Roles = roles
};

var templateCreated = templateClient.CreateTemplate(templateRequest);

import boldsign

configuration = boldsign.Configuration(host = "https://api.boldsign.com", api_key = "YOUR_API_KEY")

with boldsign.ApiClient(configuration) as api_client:

    template_api = boldsign.TemplateApi(api_client)
    
    form_fields = [
        boldsign.FormField(
            id = "sign_id",
            name = "sign",
            fieldType = "Signature",
            page_number = 1,
            font = "Helvetica",
            bounds = boldsign.Rectangle(x = 50, y = 100, width = 100, height = 60),
            is_required = True
        )
    ]
    
    role = [
        boldsign.TemplateRole(
            index = 1,
            name = "Hr",
            defaultSignerName = "Alex Gayle",
            defaultSignerEmail = "[email protected]",
            signerOrder = 1,
            signerType = "Signer",
            locale = "EN",
            imposeAuthentication = "None",
            deliveryMode = "Email",
            formFields = form_fields,
            allowRoleEdit = True,
            allowRoleDelete = True
        )
    ]
    
    create_template_request = boldsign.CreateTemplateRequest(
        enableReassign = True,
        allowNewRoles = True,
        enablePrintAndAssign = False,
        documentMessage = "document message for signers",
        enableSigningOrder = False,
        useTextTags = False,
        title = "title of the template",
        allowMessageEditing = True,
        description = "testingDescription",
        documentTitle = "title of the document",
        allowNewFiles = True,
        roles = role,
        files = ["YOUR_FILE_PATH"]
    )

    template_created = template_api.create_template(create_template_request = create_template_request)

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

use BoldSign\Configuration;
use BoldSign\Api\TemplateApi;
use BoldSign\Model\{FormField, Rectangle, TemplateRole, CreateTemplateRequest};

$config = new Configuration();
$config->setHost("https://api.boldsign.com");
$config->setApiKey('YOUR_API_KEY');

$template_api = new TemplateApi($config);

$form_field = new FormField();
$form_field->setId('sign_id');
$form_field->setName('Sign');
$form_field->setFieldType('Signature');
$form_field->setFont('Helvetica');
$form_field->setPageNumber(1);
$form_field->setIsRequired(true);
$bounds = new Rectangle([50, 100, 100, 60]);
$form_field->setBounds($bounds);

$role = new TemplateRole();
$role->setIndex(1);
$role->setName('HR');
$role->setDefaultSignerName('Alex Gayle');
$role->setDefaultSignerEmail('[email protected]');
$role->setSignerOrder(1);
$role->setSignerType('Signer');
$role->setLocale('EN');
$role->setDeliveryMode('Email');
$role->setAllowRoleEdit(true);
$role->setAllowRoleDelete(true);
$role->setImposeAuthentication('None');
$role->setFormFields([$form_field]);

$create_template = new CreateTemplateRequest();
$create_template->setEnableReassign(true);
$create_template->setAllowNewRoles(true);
$create_template->setEnablePrintAndAssign(false);
$create_template->setDocumentMessage('document message for signers');
$create_template->setEnableSigningOrder(false);
$create_template->setUseTextTags(false);
$create_template->setTitle('Php examples');
$create_template->setAllowMessageEditing(true);
$create_template->setDocumentTitle('title of the document');
$create_template->setDescription('testing Description');
$create_template->setAllowNewFiles(true);
$create_template->setRoles([$role]);
$create_template->setFiles(['YOUR_FILE_PATH']);

$template_created = $template_api->createTemplate([$create_template]);

ApiClient client = Configuration.getDefaultApiClient();
client.setBasePath("https://api.boldsign.com");
client.setApiKey("YOUR_API_KEY");

TemplateApi templateApi = new TemplateApi(client);

FormField signatureField = new FormField();
signatureField.setId("sign_id");
signatureField.setName("Signature");
signatureField.setFieldType(FormField.FieldTypeEnum.SIGNATURE);
signatureField.setPageNumber(1);
signatureField.setFont(FormField.FontEnum.HELVETICA);
signatureField.setIsRequired(true);
Rectangle bounds = new Rectangle().x(100f).y(100f).width(100f).height(50f);
signatureField.setBounds(bounds);

TemplateRole templateRole = new TemplateRole();
templateRole.setIndex(1);
templateRole.setName("Hr");
templateRole.setDefaultSignerName("Alex Gayle");
templateRole.setDefaultSignerEmail("[email protected]");
templateRole.setSignerOrder(1);
templateRole.setSignerType(TemplateRole.SignerTypeEnum.SIGNER);
templateRole.setLocale(TemplateRole.LocaleEnum.EN);
templateRole.setFormFields(Arrays.asList(signatureField));
templateRole.setDeliveryMode(TemplateRole.DeliveryModeEnum.EMAIL);
templateRole.setAllowRoleEdit(true);
templateRole.setAllowRoleDelete(true);
templateRole.setImposeAuthentication(TemplateRole.ImposeAuthenticationEnum.NONE);

CreateTemplateRequest createTemplate = new CreateTemplateRequest();
createTemplate.setEnableReassign(true);
createTemplate.setAllowNewRoles(true);
createTemplate.setEnablePrintAndAssign(false);
createTemplate.setDocumentMessage("document message for signers");
createTemplate.setEnableSigningOrder(false);
createTemplate.setUseTextTags(false);
createTemplate.setTitle("title of the template");
createTemplate.setAllowMessageEditing(true);
createTemplate.setDescription("testing Description");
createTemplate.setDocumentTitle("title of the document");
createTemplate.setAllowNewFiles(true);
createTemplate.setRoles(Arrays.asList(templateRole));

File file = new File("YOUR_FILE_PATH");
createTemplate.setFiles(Arrays.asList(file));

TemplateCreated templateCreated = templateApi.createTemplate(createTemplate);

import { TemplateApi, CreateTemplateRequest, TemplateRole, Rectangle, FormField } from "boldsign";
import * as fs from 'fs';

const templateApi = new TemplateApi("https://api.boldsign.com");
templateApi.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.id = "sign_id";
formField.name = "Signature";
formField.fieldType = FormField.FieldTypeEnum.Signature;
formField.pageNumber = 1;
formField.font = FormField.FontEnum.Helvetica;
formField.isRequired = true;
formField.bounds = bounds;

const role = new TemplateRole();
role.index = 1;
role.name = "HR";
role.defaultSignerEmail = "[email protected]";
role.defaultSignerName = "Alex Gayle";
role.signerOrder = 1;
role.locale = TemplateRole.LocaleEnum.En;
role.signerType = TemplateRole.SignerTypeEnum.Signer;
role.deliveryMode = TemplateRole.DeliveryModeEnum.Email;
role.allowRoleEdit = true;
role.allowRoleDelete = true;
role.imposeAuthentication = TemplateRole.ImposeAuthenticationEnum.None;
role.formFields = [formField];

const file = fs.createReadStream("YOUR_FILE_PATH");

const createTemplateRequest = new CreateTemplateRequest();
createTemplateRequest.title = "title of the template";
createTemplateRequest.documentTitle = "title of the document";
createTemplateRequest.enableReassign = true;
createTemplateRequest.allowNewRoles = true;
createTemplateRequest.enablePrintAndAssign = false;
createTemplateRequest.documentMessage = "document message for signers";
createTemplateRequest.description = "testing Description";
createTemplateRequest.enableSigningOrder = false;
createTemplateRequest.useTextTags = false;
createTemplateRequest.allowMessageEditing = true;
createTemplateRequest.allowNewFiles = true;
createTemplateRequest.roles = [role];
createTemplateRequest.files = [file];

const templateCreated = templateApi.createTemplate(createTemplateRequest);

In the provided code example, provide values for Roleindex, Rolename. Replace the values for API KEY with the correct value, Filewith your correct file path. When the above codes are executed, a template is created successfully with the values provided and templateId is returned.