Signature Detection in Tensorlake: Catch what’s missing, trigger what’s next
TL;DR
Tensorlake's new Signature Detection feature goes beyond basic signature identification. It not only detects the presence and location of signatures in documents but also extracts contextual information like signer names and dates. This enables automated workflow triggers and compliance checks. The feature works with all document types (PDFs, forms, scanned contracts) and integrates seamlessly with existing Tensorlake pipelines. Available now in both the Playground and SDK with pay-as-you-go pricing at $0.01 per page.
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:
1detect_signature=TrueFor 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 signtures on the document:
1from tensorlake.documentai import DocumentAI
2from tensorlake.documentai.parse import ParsingOptions
3import time
4
5# Initialize the client and add your API Key
6doc_ai = DocumentAI(api_key="YOUR_API_KEY")
7
8# Upload the document
9file_url = "https://tlake.link/docs/real-estate-agreement"
10
11# Create a schema
12class Buyer(BaseModel):
13 buyer_name: str
14 buyer_signature_date: str
15 buyer_signed: bool
16
17class Seller(BaseModel):
18 seller_name: str
19 seller_signature_date: str
20 seller_signed: bool
21
22class RealEstateSchema(BaseModel):
23 buyer: Buyer
24 seller: Seller
25
26
27real_state_extraction = StructuredExtractionOptions(
28 schema_name="real-estate-schema",
29 json_schema=RealEstateSchema
30)
31
32# Configure parsing options
33parsing_options = ParsingOptions(
34 signature_detection=True
35)
36
37parse_id = doc_ai.parse(
38 file=file_path,
39 parsing_options=parsing_options,
40 structured_extraction_options=[real_state_extraction],
41)
42
43print(f"Parse job submitted with ID: {parse_id}")
44
45# Get the result
46result = doc_ai.wait_for_completion(parse_id)
47
48if(result.status == ParseStatus.FAILURE):
49 print("Parse job failed!")
50 exit(1)
51
52print("Successully parsed the document!")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:
- You only pay for what you use
- Pricing is the same for all processing tasks, including Signature Detection
- No minimums or subscriptions
Check out the Tensorlake Examples for more detailed examples, including:
Got feedback or want to show us what you built? Join the conversation in our Slack Community!
Dr Sarah Guthals
Founding DevRel Engineer at Tensorlake
Founding DevRel Engineer at Tensorlake, blending deep technical expertise with a decade of experience leading developer engagement at companies like GitHub, Microsoft, and Sentry. With a PhD in Computer Science and a background in founding developer education startups, I focus on building tools, content, and communities that help engineers work smarter with AI and data.