Launched in August 2024, the new Text Tagging feature revolutionizes how developers prepare dynamic documents for digital signatures. It simplifies the integration process by using document content to define field anchors, eliminating the need for complex PDF libraries.
This article explores the functionality of Text Tagging, demonstrates its implementation through a sample web application, and highlights its potential to streamline document workflows across various industries. Whether you're a developer, product manager, or project lead, understanding Text Tagging can significantly enhance your digital signature integration capabilities with SIGNiX.
Before Text Tagging, documents submitted to SIGNiX via the API required pre-existing fields in static PDFs. While this approach worked fine when developers could embed fields using desktop tools like Adobe Acrobat, it posed challenges for dynamic documents, where content “reflows” from transaction to transaction due to variables. These reflowing documents often caused signature fields and other important elements to move, complicating the signing process.
Existing SIGNiX integrations could handle dynamic documents by introducing PDF libraries, but this approach often led to increased costs and complexity for developers.
Text Tagging eliminates the need to create and manage PDF libraries to place fields in dynamic PDFs, making it easier and more cost-effective for developers. Moreover, text tagging makes it easier for technically savvy staff to use no-code or light-coding solutions (e.g., Microsoft Word, HTML, etc) to generate documents ready for the signature workflow. By aligning with similar workflows in other e-signature platforms, text tagging provides customers a seamless transition to SIGNiX if they’re migrating from other e-signature providers.
Text Tagging works by scanning the document for specific keywords or phrases called anchors (e.g. “Signature:” or “Lessee:”) to place signature fields in the correct positions. Developers can define where these fields appear relative to those anchors based on a simple coordinate system.
The lower-left corner of the anchor text serves as the origin point of the signature field. A coordinate system (measured in points, or 1/72 inch) is used to position fields relative to the origin. You can then define the field’s height, width, and position based on offsets.
When submitting a transaction via the API, the SubmitDocument method extends to include one or more <TextTagField> elements.
These elements specify details such as:
An alternative to using visible anchor text is "white text tagging". This involves using text that's the same color as the page background, making it invisible to the human eye but detectable by the system. This approach is particularly useful for documents with multiple fields, allowing for unique identifiers like %SIG1% that only the application and SIGNiX can see.
Click here for more technical details on Text Tagging.
Here’s a sample structure:
Note that the <TextTagField> elements replace the normal SubmitDocument elements for fields, which is important for developers familiar with the previous method.
Click here for more technical details on the SubmitDocument API call.
We’ve created a sample application for developers to review, modify, or use as the foundation of another project. It’s written in Python, utilizing Flask and several other Python modules. Developers will need to install the open-source WebKit HTML To PDF utility (wkhtmltopdf).
Click here to access the GitHub repository.
To understand the Text Tagging feature’s role in an end-to-end solution, the demo application goes beyond the call to SIGNiX and demonstrates step-by-step the lifecycle of a simple transaction:
The demo also includes a static document for comparison, helping developers understand the differences between handling static and dynamic documents.
These steps are wrapped into a simple web application easily accessed via a browser.
In the demo application, the dynamic document has two signature fields and two date fields automatically populated by SIGNiX when the document is signed.
The content of the document can vary (for example, more jet packs could be added to the list of vehicles being leased). However, the signature lines are always positioned relative to specific text anchors, such as "LESSOR:" and "LESSEE:" for signature fields.
To handle these fields, the application defines a "document set" object in a JSON-like format.
Here's an expanded version of the document set object, including both dynamic and static document examples:
The sample application uses Python's ElementTree module to construct the XML for the SubmitDocument call. Here's a quick overview of the process:
Visit the GitHub repository to download or fork the sample project, review the code, and see how Text Tagging works in a simplified signature workflow:
https://github.com/kmsignix/zoom-jet-packs
To send transactions to SIGNiX, you’ll need a developer account. To request one or to learn more about SIGNiX and Text Tagging, complete the following form: