Tatvora OCR AI
Turn documents into usable data.
Extract text and structured information from images, scans, PDFs and office documents through a single document intelligence API.
Production-ready AI APIs for OCR, face detection, recognition, verification, liveness detection and intelligent text prediction.
Build intelligent applications without building complex AI infrastructure from scratch.
{
"success": true,
"text": "Extracted document content...",
"processing_time_ms": 412
}
Tatvora develops AI models and exposes them through simple REST APIs. Businesses and developers get advanced AI capabilities without hiring an ML team, procuring GPUs or operating inference infrastructure.
Each model is built for a specific real-world job rather than stretched across every task. You call the endpoint that matches the problem, and receive a predictable JSON response your application can act on.
See how integration worksStandard HTTPS endpoints that work with any language or framework.
Consistent, predictable payloads with a stable success and error shape.
Bearer-token authentication with separate development and production keys.
Per-model and per-key consumption visible in the dashboard.
Per-plan request limits that protect both your application and the platform.
Endpoint reference, request and response schemas and integration examples.
Six production APIs across document intelligence, face intelligence and predictive text. Use one, or combine several in a single workflow.
Turn documents into usable data.
Extract text and structured information from images, scans, PDFs and office documents through a single document intelligence API.
Detect human faces inside images and video frames.
Locate human faces in an image or camera frame and return their position as bounding boxes.
Recognise identities using intelligent facial analysis.
Match a captured face against the identity set your application supplies to determine who the person is.
Verify whether two faces belong to the same person.
Compare a reference image against a live capture and receive a match or no-match decision with a similarity score.
Verify that the person in front of the camera is real and live.
Determine whether a captured face belongs to a physically present person rather than a printed photo or replayed screen.
Make typing faster and smarter.
A context-aware next-word prediction API that adds predictive typing and sentence completion to any text input.
Detection, recognition, verification and liveness are separate AI models with separate endpoints. Call them individually, or chain them into an authentication workflow.
Locate human faces in an image or camera frame and return their position as bounding boxes.
Match a captured face against the identity set your application supplies to determine who the person is.
Compare a reference image against a live capture and receive a match or no-match decision with a similarity score.
Determine whether a captured face belongs to a physically present person rather than a printed photo or replayed screen.
A typical authentication workflow chains them together
Each API is billed and called independently — combine only the steps your workflow needs. Explore the Face AI platform
Practical AI, developer-first ergonomics and pricing that improves as you grow.
Add advanced AI capabilities using simple REST APIs. One HTTP call, an API key header, and a JSON response your application can act on.
Access specialised AI models built for specific real-world requirements rather than one general model stretched across every task.
Clear APIs, predictable JSON responses and straightforward authentication, with examples in cURL, Python, JavaScript, C# and Java.
Move from development to production without rebuilding your AI architecture. The same endpoints serve your prototype and your platform.
Start small and receive progressively better effective pricing as your API usage increases, with transparent per-request maths on every plan.
Designed for integration into real business applications, with usage tracking, request logs, rate limiting and quota management from day one.
Your application sends an authenticated HTTPS request. We route it to the model, run inference and return JSON.
Authenticate with a bearer key, post your file or JSON body, read a predictable response. Examples ship for cURL, Python, JavaScript, C# and Java.
HttpClient, with guidance on IHttpClientFactorysuccess, request_id and error shape across every modelcurl -X POST https://api.tatvora.comPOST /api/v1/ocr \
-H "Authorization: Bearer $TATVORA_API_KEY" \
-F "document=@invoice.pdf"
import os
import requests
with open("invoice.pdf", "rb") as f1:
response = requests.post(
"https://api.tatvora.comPOST /api/v1/ocr",
headers={"Authorization": f"Bearer {os.environ['TATVORA_API_KEY']}"},
files={"document": f1},
timeout=30,
)
response.raise_for_status()
print(response.json())
const form = new FormData();
form.append("document", documentFile); // File or Blob
const response = await fetch("https://api.tatvora.comPOST /api/v1/ocr", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.TATVORA_API_KEY}` },
body: form,
});
if (!response.ok) {
throw new Error(`Tatvora API error ${response.status}`);
}
const result = await response.json();
console.log(result);
using System.Net.Http.Headers;
var apiKey = Environment.GetEnvironmentVariable("TATVORA_API_KEY");
using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
using var form = new MultipartFormDataContent();
using var stream1 = File.OpenRead("invoice.pdf");
var part1 = new StreamContent(stream1);
part1.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
form.Add(part1, "document", "invoice.pdf");
using var response = await client.PostAsync("https://api.tatvora.comPOST /api/v1/ocr", form);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
// Prefer IHttpClientFactory over `new HttpClient()` in ASP.NET Core apps:
// builder.Services.AddHttpClient("OcrClient", c =>
// c.BaseAddress = new Uri("https://api.tatvora.com"));
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
public class OcrExample {
public static void main(String[] args) throws Exception {
Map<String, Path> files = new LinkedHashMap<>();
files.put("document", Path.of("invoice.pdf"));
String boundary = "tatvora-" + UUID.randomUUID();
HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.tatvora.comPOST /api/v1/ocr"))
.header("Authorization", "Bearer " + System.getenv("TATVORA_API_KEY"))
.header("Content-Type", "multipart/form-data; boundary=" + boundary)
.POST(multipart(boundary, files))
.build();
HttpResponse<String> response = HttpClient.newHttpClient()
.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode() + " " + response.body());
}
private static HttpRequest.BodyPublisher multipart(String boundary, Map<String, Path> files)
throws IOException {
List<byte[]> parts = new ArrayList<>();
for (Map.Entry<String, Path> file : files.entrySet()) {
parts.add(("--" + boundary + "\r\n"
+ "Content-Disposition: form-data; name=\"" + file.getKey()
+ "\"; filename=\"" + file.getValue().getFileName() + "\"\r\n"
+ "Content-Type: application/octet-stream\r\n\r\n").getBytes());
parts.add(Files.readAllBytes(file.getValue()));
parts.add("\r\n".getBytes());
}
parts.add(("--" + boundary + "--\r\n").getBytes());
return HttpRequest.BodyPublishers.ofByteArrays(parts);
}
}
Start with an evaluation key, validate the model against your own data, then scale the same integration into production.
Create or request an account
Register for a Tatvora developer account or request access from our team.
Select an API plan
Choose the tier matched to your expected volume, starting at $49 per month for 5,000 calls.
Receive an API key
Generate a key from the dashboard. The secret is shown once at creation.
Choose an AI API
Pick the model that matches the job — OCR, face detection, recognition, verification, liveness or prediction.
Send API requests
Call the REST endpoint over HTTPS with your key in the Authorization header.
Receive JSON responses
Handle a predictable JSON payload with a consistent success flag, request id and error shape.
Monitor API usage
Track consumption, success rates and per-model usage from the dashboard.
Upgrade as the application grows
Move to a higher plan for better effective pricing and higher limits as volume increases.
The same six APIs support very different workflows depending on how they are combined.
Every vertical below is served by the same APIs, combined differently.
Here is what the platform does today. We do not claim SOC 2, ISO 27001, HIPAA, GDPR certification or PCI compliance, because we do not currently hold them. If your procurement process requires specific attestations, talk to us about an enterprise agreement.
Discuss enterprise requirementsStart small. Save more as you scale.
Developers, prototypes and small applications.
5,000 API calls
~$0.0098 / request
Startups, SaaS applications and growing businesses.
15,000 API calls
~$0.0066 / request
Established businesses and production workloads.
50,000 API calls
~$0.0050 / request
Where an off-the-shelf model does not fit the problem, Tatvora takes on custom AI development for specific business requirements and delivers the result as an API on the same platform.
Discuss Your AI RequirementCustom quotas and volume-based pricing, dedicated capacity, private deployment options and enterprise security controls.
250,000+, 500,000+, 1,000,000+ or a volume shaped around your forecast, with pricing to match.
Dedicated API capacity and private deployment options where shared infrastructure is not acceptable.
IP whitelisting, a signed Data Processing Agreement, multiple developer accounts and enterprise access controls.
Named support contacts, SLA options, custom reporting and integration assistance.
More detail on models, pricing and integration is on the developer and pricing pages.
Tell us what you are building and we will issue an evaluation key so you can validate the models against your own documents and images before you commit to a plan.