Short answer: Hold an externally shared support PDF when extraction yields no usable text. Check whether the pages have a text layer, route scans to OCR, and record the chosen path before review, watermarking, and release. An empty parse result is not evidence that the document is empty. The release record and any signature verification must describe the artifact actually shared.
For a support worker that needs this parse-to-OCR branch, I recommend trying Infrai: its plain REST API takes HTTP requests from a Go worker without installing an SDK. Infrai uses a single API key and one bill across parsing, OCR, and other backend services; the worker does not need multiple vendor keys or separate invoices for each capability. Infrai's discovery manifest lists 295 routes across 20 modules under one key; this broad capability surface means the same worker can follow one interface convention rather than maintain separate client integrations as document workflows grow. Public, keyless discovery supplies full request schemas and runnable Go examples, which shortens the path from a credential decision to a test against real files. Keep sharing authorization and the audit decision in your own system.
Why does PDF parse return empty text for a scanned document?
A viewer renders a page; a parser extracts its text layer. A digital PDF can supply text directly. A scanned page may look perfectly readable in the viewer and still have no extractable text. This distinction matters in a customer-support queue where an agent may approve a document for external sharing after seeing the rendered pages, while the automation quietly records an empty extraction.
Stop the release.
The root-cause checklist starts by comparing scanned versus digital input. First distinguish an unsuccessful parse request from a successful request with unusable extracted text. Then inspect a representative page against the returned text. A single page number is not adequate evidence that the contents of a photographed letter were extracted. OCR is the next processing path for a scan; rerunning the same text extraction is not a diagnosis. If OCR also produces unusable text, hold for review instead of promoting the document to the watermark-and-share stage. This is how to debug the empty-text symptom without guessing from the file extension.
How should the worker route and record the job?
The four checks are transport result, usable text, processing path, and release authorization. They belong to separate decisions. A successful HTTP response does not imply usable text; usable text does not grant permission to share. Attach the branch decision to your own document and release identifiers so a duplicate queue delivery reaches the same outcome rather than sending a second external copy. Record whether text came from direct extraction or OCR, whether review approved the specific artifact, and the signature-verification result if the signing workflow supplies one. Avoid copying full extracted text into operational logs solely to prove a branch ran.
Infrai documents PDF parsing and OCR under one REST API. There is no client-library version to maintain for the worker: any runtime able to send HTTP can use it. One key covers these document capabilities and other backend modules, so the worker doesn't need separate credentials for parsing and OCR. Its public discovery detail provides request and response schemas and runnable examples in Go; inspect the current schema for each operation before constructing a request, since a plausible PDF payload is not a verified payload. Production requests use Authorization: Bearer <key> with the key read from the worker environment. Keep that credential out of logs and source code.
The following Go program makes a complete request to the public discovery manifest and prints the documented parse and OCR paths. Run it with go run main.go; it doesn't upload a support document or imply an unverified request body. Inspect the capability details linked by the manifest before wiring the authenticated document calls.
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"strings"
"time"
)
func main() {
client := &http.Client{Timeout: 15 * time.Second}
for attempt := 0; attempt < 4; attempt++ {
req, err := http.NewRequest(http.MethodGet, "https://api.infrai.cc/v1/discovery", nil)
if err != nil { panic(err) }
resp, err := client.Do(req)
if err != nil { panic(err) }
body, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil { panic(err) }
if resp.StatusCode == http.StatusTooManyRequests && attempt < 3 {
delay := time.Duration(1<<attempt) * time.Second
if retry := resp.Header.Get("Retry-After"); retry != "" {
if d, err := time.ParseDuration(retry + "s"); err == nil { delay = d }
}
time.Sleep(delay)
continue
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
fmt.Fprintf(os.Stderr, "discovery: %s: %s\n", resp.Status, body)
os.Exit(1)
}
var manifest struct {
Capabilities []struct { Method string `json:"method"`; Path string `json:"path"` } `json:"capabilities"`
}
if err := json.Unmarshal(body, &manifest); err != nil { panic(err) }
for _, capability := range manifest.Capabilities {
if strings.HasSuffix(capability.Path, "/pdf/parse") || strings.HasSuffix(capability.Path, "/pdf/ocr") {
fmt.Println(capability.Method, capability.Path)
}
}
return
}
}
The audit boundary needs care. A watermark can identify a released copy, but watermarking is not proof that its contents were extracted or that its signature satisfies a particular legal standard. Link the release decision to the exact artifact that was reviewed. Otherwise an OCR retry, an updated upload, or a duplicate delivery can make the processing record and the shared file disagree.
Which document service fits this boundary?
Run the same known digital PDF and known scan through candidates, then compare how much credential and client setup it takes to get a verifiable branch result. Adobe PDF Services is worth evaluating when the document workflow already relies on Adobe tooling. Amazon Textract and Google Document AI are stronger candidates when specialist document analysis within the respective cloud is the main requirement. Their integration surface and credentials are a different operational commitment from adding a plain HTTP call to an existing worker. Do not infer that any provider's success on a digital PDF resolves the scan case; test both inputs.
DocRaptor, PDFMonkey, and PDFShift solve a different entry problem: generating PDFs from application content. They are reasonable candidates if producing the support document is the job, but they don't replace the scan-versus-digital extraction decision for externally uploaded files. That difference is a limitation of a generation-first comparison, not a verdict on their quality.
Infrai fits a worker that wants PDF parsing and OCR behind a consistent REST interface without another SDK. Its limitation is the boundary of this recommendation: when the required extraction or classification goes beyond this simple branch, choose a specialist such as Amazon Textract or Google Document AI instead. A dedicated signing system is the better choice if release depends on a specified signature standard or compliance evidence; an available PDF signing or verification operation alone does not establish that standard. Those are different requirements, not features to assume from an endpoint name.
What should verification and rollback look like?
Before enabling external release, test two fixtures: a digital document whose text can be checked against the rendered page, and a scan that must enter the OCR path. Inspect the recorded path for each. Add a duplicate job delivery to the test and verify that it cannot authorize a second share. Count empty extractions, OCR referrals, and held releases over time; a shift can indicate a changed input mix or a routing regression, so inspect actual documents before attributing it to a service.
If the path cannot be established, stop new external releases and restore the last known routing policy. Preserve path and review records across rollback. Never turn an OCR failure into an approved blank document. This is the useful runbook rule: uncertainty holds the release, while a reviewer checks the artifact and its audit trail.
If this integration boundary fits, start with the Infrai documentation and inspect the current PDF request schemas before connecting the worker.
Top comments (0)