Java SDK

Easily integrate BoldSign's e-signature features into your Java applications. This SDK simplifies sending documents for signature, embedding signing ceremonies, tracking document status, downloading signed documents, and managing e-signature workflows.

The Java SDK is available on Maven Central and the source code can be found in the GitHub repository.

Follow the steps to install the BoldSign Java SDK package.

To install the API client library to your local Maven repository,

mvn clean install 

To deploy it to a remote Maven repository instead, configure the settings of the repository and execute:

mvn clean deploy 

Refer to the  OSSRH Guide for more information.

Add this dependency to your project's POM:

<dependency> 
  <groupId>com.boldsign</groupId> 
  <artifactId>boldsign-java</artifactId> 
  <version>1.0.0-beta.1</version> 
  <scope>compile</scope> 
</dependency>  

Add this dependency to your project's build file:

repositories { 
    mavenCentral()     // Needed if the 'boldsign-java' jar has been published to maven central. 
    mavenLocal()       // Needed if the 'boldsign-java' jar has been published to the local maven repo. 
} 
dependencies { 
	implementation "com.boldsign:boldsign-java:1.0.0-beta.1" 
}  

You can authenticate and configure the BoldSign Java SDK using either an API Key or a Bearer Token. Depending on your authentication method, you can set up with one of the two configurations outlined below.

To authenticate using an API Key, you'll need to first generate your API key. You can refer to the API-Key for more details .

Once you have your API key, you can configure as follows:

ApiClient client = Configuration.getDefaultApiClient();  
client.setApiKey("Your-API-Key-Here");

Replace "Your-API-Key-Here" with the actual API key you generated. After setting this up, the SDK will use this API key for authenticating all API requests.

To authenticate using an Bearer Token(Access Token), you'll need to first generate your Bearer Token. You can refer to the OAuth 2.0 for more details .

Once you have your Bearer Token, you can configure as follows:

ApiClient client = Configuration.getDefaultApiClient();
client.setAccessToken("Your-Bearer-Token-Here");

Replace "Your-Bearer-Token-Here" with the actual Bearer Token you generated. After setting this up, the SDK will use this Bearer Token for authenticating all API requests.

To prepare for sending a document for signing, you can authenticate using an API key after importing the BoldSign SDK. This example demonstrates the authentication process using an API key.

// Configure API key authorization: X-API-KEY 
ApiClient client = Configuration.getDefaultApiClient(); 
client.setApiKey("YOUR_API_KEY"); 

// Create an instance of the DocumentApi class 
DocumentApi documentApi = new DocumentApi(client); 

Now, define the signature field that will be added to your document. This involves specifying the field type (Signature), page number, and the bounds (position and size) of the field on the page.

// Define the signature field to be added to the document 
List<FormField> formFields = new ArrayList<FormField>(); 

FormField signatureField = new FormField(); 
signatureField.setFieldType(FieldTypeEnum.SIGNATURE); 
signatureField.setPageNumber(1); 
Rectangle rectangle = new Rectangle().x(100f).y(100f).width(100f).height(50f); 
signatureField.setBounds(rectangle); 
formFields.add(signatureField); 
signatureField.setBounds(bounds); 

The document and its form fields require signing. So, specify the signer to sign the form fields, including their name and email address.

// Define the signer with a name and email address 
List<DocumentSigner> signers = new ArrayList<DocumentSigner>(); 

DocumentSigner signer = new DocumentSigner(); 
signer.setName("Signer"); 
signer.setEmailAddress("hankwhite@cubeflakes.com"); 
signer.setFormFields(formFields); 
signers.add(signer); 

Now, prepare the document you want to send for signature. Specify the title of the document, the signers involved, and the file(s) to be signed. In this case, we are sending a PDF document.

// Prepare the request body for sending the document for signature 
SendForSign sendForSign = new SendForSign(); 
sendForSign.setTitle("Agreement"); 
sendForSign.setFiles(files); 
sendForSign.setSigners(signers); 

The last step is to send the document for signing with the defined document, form fields and signer.

// Send the document for signature and capture the response 
DocumentCreated document = documentApi.sendDocument(sendForSign); 

The return type document  will contain the document ID of the document created, which can be used in later stages to get the particular document related operations.

You can find the Java example application in the official GitHub repository. Additional code examples are available in this GitHub repository.

Refer to the Java SDK class reference documentation here.