Signature Detection in Tensorlake: Catch what’s missing, trigger what’s next

Missing signatures might seem like a minor issue...until they delay approvals, cause compliance problems, or derail entire workflows.

That’s why we’ve prioritized support for Signature Detection, which is now generally available in Tensorlake Cloud.

Tensorlake's Signature Detection has two critical features:

Basic Signature Detection: Like other document parsers, you can detect whether a document contains a signature and where it is located.
Contextual Signature Detection: You can also extract additional, relevant, contextual information on the page (e.g. the names of the signers and the date they signed).

This new feature enables you to automatically detect the presence (or absence) of signatures in documents of all types (e.g. PDFs, forms, scanned contracts), extract contextual data around the signature, and use the results to trigger additional workflows; including automations, flag edge cases, or route documents for human review.

Bottlenecks begin with missing signatures

In high-stakes workflows, like insurance claims, legal agreements, and onboarding packets, signatures aren’t optional. They confirm intent, authorize action, and serve as legal proof. And yet, missing signatures are one of the most common causes of delays and compliance failures.

A single missed signature can:

Stall a multi-million dollar claim
Invalidate a contract
Trigger audit flags
Force teams to track down a person who’s already moved on

And when you’re dealing with hundreds or thousands of documents, many of them multi-page, multi-party, and in varying formats, it’s easy for signature gaps to slip through unnoticed until it’s too late.

With Signature Detection in Tensorlake, you can now programmatically determine whether a document has been signed. But what sets Tensorlake apart is we don’t just identify that a signature shape exists on the page, we analyze the content visually and structurally to identify handwritten, typed, or image-based marks that signal intent and authorization.

Seamlessly combine it with any other parsing logic you’ve configured (e.g. extracting form fields, tables, or custom schema-defined values) to create a structured, yet comprehensive understanding of the document.

And with native support for orchestration, it fits directly into your existing Tensorlake pipelines or tools like LangGraph, Zapier, or even your internal systems.

How to do basic Signature Detection with Tensorlake

You can use Signature Detection to automatically identify whether a document has been signed, and where the signatures are located. This is what you are likely used to with other document parsers, and with Tensorlake you can do this with any document type, including PDFs, images, and scanned documents.

Let’s say you process real estate sales that require two signatures: one from the buyer and one from the seller.

With the SDK, enabling basic Signature Detection is as simple as setting a single boolean in your ParsingOptions:
detect_signature=True

For example, if you wanted to detect whether signatures existed in this document, this code will detect the signatures and find the bounding boxes of all signatures on the document:

from tensorlake.documentai import DocumentAI
from tensorlake.documentai.parse import ParsingOptions
import time

# Initialize the client and add your API Key
doc_ai = DocumentAI(api_key="YOUR_API_KEY")

# Upload the document
document_id = doc_ai.upload(path="data/real-estate-purchase-all-signed.pdf")

# Configure parsing options
options = ParsingOptions(
  detect_signature=True
)

# Parse the document
job_id = doc_ai.parse(document_id, options)

# Get the result
result = doc_ai.get_job(job_id)

# Wait for the job to complete and print the result
while True:
  if result.status in ["pending", "processing"]:
      print("waiting 5s...")
      time.sleep(5)
      result = doc_ai.get_job(job_id)
      print(f"job status: {result.status}")
  else:
      if result.status == "successful":
          print("Successully parsed the document!")
          print(result.model_dump())
          break

This will return a JSON object with the detected signatures, including their bounding boxes and whether they are handwritten or typed. To make this easier to see, here is a screenshot from the Tensorlake Playground showing the result of detecting the signatures on the last page of the document, and the associated bounding boxes visualized on the page:

Contextual Signature Detection with Tensorlake

With Tensorlake, you can also extract additional context around signatures, such as the names of the signers and the date they signed. This is particularly useful in workflows where you need to know who signed a document and when, such as in legal agreements or contracts.

If you want to extract additional context around signatures, like the names of the Buyer and Seller and the date they signed, check out this cookbook on our Docs.

You can also do this in the Tensorlake Playground with just a few clicks.

This demo shows how to detect signatures and extract the names of the Buyer and Seller using the Playground:

Try out Signature Detection

Tensorlake's Signature Detection is designed to be easy to use, but powerful enough to handle complex workflows.

Out of the box, you can::

Extract contextual information around signatures, such as the names of the signers and the date they signed
Detect whether all signatures are present and where the signatures are located within the document
Trigger a workflow if a required signature is missing (e.g., send a Slack ping, flag the file for review)

You can try Signature Detection right now in the both the Tensorlake Playground and using the Python SDK. We also have
other use cases in our Tensorlake Docs.

When you sign up for the Playground, you get 100 free credits to use, where each credit is essentially a single page. After that, Tensorlake is pay-as-you-go at only $0.01 per page and: