Getting started

go get github.com/voidrab/gopdfrab

doc, err := gopdfrab.Open(path)
if err != nil {
	log.Fatal(err)
}
defer doc.Close()

v, _ := doc.Verify(gopdfrab.PDFA1B)

if v.Valid {
	fmt.Println("Document is PDF/A-1b compliant")
} else {
	fmt.Println("Issues:")
	for i, issue := range v.Issues {
		fmt.Printf("#%v: %v\n", i+1, issue)
	}
}

// Verify opens, verifies, and closes a file in one call
result, err := gopdfrab.Verify(path, gopdfrab.PDFA1B)
if err != nil {
	log.Fatal(err)
}
fmt.Println(result.Valid)

// VerifyBytes is Verify for an in-memory PDF
result, err := gopdfrab.VerifyBytes(data, gopdfrab.PDFA1B)

results, err := gopdfrab.VerifyAll(paths, gopdfrab.PDFA1B)
if err != nil {
	log.Fatal(err)
}
for _, r := range results {
	if r.Err != nil {
		log.Println(r.Path, r.Err)
		continue
	}
	fmt.Println(r.Path, r.Result.Valid)
}

cr, err := gopdfrab.Convert(path, gopdfrab.PDFA1B)
if err != nil {
	log.Fatal(err)
}
defer cr.Close() // releases the output (a large one spills to a temp file)

if err := cr.Save("out.pdf"); err != nil {
	log.Fatal(err)
}

fmt.Println(cr.Iterations)      // how many verify/fixup passes it took
fmt.Println(cr.Result.Valid)    // true if the output is fully PDF/A conformant

// Converting an open document
cr, err := doc.Convert(gopdfrab.PDFA1B)
defer cr.Close()

// Converting in-memory data
cr, err = gopdfrab.ConvertBytes(data, gopdfrab.PDFA1B)

// Converting multiple files concurrently
results, err := gopdfrab.ConvertAll(paths, gopdfrab.PDFA1B)
if err != nil {
	log.Fatal(err)
}
for _, r := range results {
	if r.Err != nil {
		log.Println(r.Path, r.Err)
		continue
	}
	fmt.Println(r.Path, r.Result.Result.Valid) // r.Result is a ConvertResult
}

// Inspecting residual issues after conversion
residual := cr.Residual()
for _, iss := range residual {
	c := iss.Check()
	fmt.Println(c.Clause(), c.Name())
	fmt.Println(iss.Page(), iss.Messages())
}

// Encrypted documents are decrypted transparently on open when they use
// the empty user password. Supply a user or owner password explicitly:
doc, err := gopdfrab.OpenWithPassword(path, []byte("secret"))
if errors.Is(err, gopdfrab.ErrPasswordRequired) {
	log.Fatal("a correct password is required to open this file")
}
defer doc.Close()

// Verify and Convert decrypt the same way, via Options.Password
res, err := gopdfrab.VerifyContext(ctx, path, gopdfrab.PDFA1B, gopdfrab.Options{
	Password: []byte("secret"),
})

res, err := gopdfrab.Verify(path, gopdfrab.PDFA1B)

switch {
case errors.Is(err, gopdfrab.ErrNotPDF):
	log.Println("not a PDF -- no %PDF- header")
case errors.Is(err, gopdfrab.ErrPasswordRequired):
	log.Println("a correct password is required")
case errors.Is(err, gopdfrab.ErrEncrypted):
	log.Println("unsupported encryption scheme")
case errors.Is(err, gopdfrab.ErrDamaged):
	log.Println("xref or trailer structure could not be parsed")
case err != nil:
	log.Println(err)
default:
	fmt.Println(res.Valid)
}

// "Is this even valid PDF?" -- independent of any PDF/A conformance level
res, err := gopdfrab.VerifyObjectModel(path)

res, err = gopdfrab.VerifyObjectModelBytes(data)
res, err = doc.VerifyObjectModel()

// Equivalent to verifying with the object-model-only profile
res, err = doc.Verify(gopdfrab.ObjectModelOnly())

// Shorthand for VerifyObjectModel().Valid
ok, err := doc.IsPDF()

// Repairs against the object-model checks only, applying every fix that is
// safe and semantics-preserving and reporting anything else as a residual.
cr, err := gopdfrab.ConvertObjectModel(path)
defer cr.Close()

cr, err = gopdfrab.ConvertObjectModelBytes(data)
cr, err = doc.ConvertObjectModel()

cr, err := gopdfrab.ConvertContext(ctx, path, gopdfrab.PDFA1B, gopdfrab.Options{
	Password:      []byte("secret"), // decrypt an encrypted input
	RasterDPI:     300,              // raster last-resort resolution (default 150)
	MaxIterations: 8,                // verify/fix loop bound (default 4)
	Workers:       4,                // batch concurrency (default runtime.NumCPU)
})
defer cr.Close()

// To set options without a deadline, pass context.Background()
res, err := gopdfrab.VerifyContext(context.Background(), path, gopdfrab.PDFA1B,
	gopdfrab.Options{Password: []byte("secret")})

// A single stream decodes to at most 256 MB by default, guarding against
// decompression bombs. Raise it for legitimately large PDFs, or lower it to
// harden against hostile input.
gopdfrab.SetLimits(gopdfrab.Limits{
	MaxDecodedStreamBytes: 512 << 20, // 512 MB
	MaxResidentBytes:      32 << 20,  // caches one open document keeps (default 64 MB)
})

gopdfrab.CurrentLimits()  // the effective caps
gopdfrab.DefaultLimits()  // the built-in caps

// Conforming to PDF/A is not the same as *looking* like the input -- a page
// blanked during conversion still verifies clean.
cr, err := gopdfrab.ConvertContext(ctx, path, gopdfrab.PDFA1B,
	gopdfrab.Options{CheckFidelity: true})
defer cr.Close()

for _, pf := range cr.Fidelity {
	if pf.Blanked() {
		log.Printf("page %d lost its content during conversion", pf.Page)
	}
}

// Content the rasterizer could not draw is reported, never silently omitted
for _, d := range cr.RasterDrops {
	log.Printf("page %d: dropped %v", d.Page, d.Features)
}

cr.RasterizedPages // pages rebuilt as a flat image

// Save writes to a file; WriteTo streams to any io.Writer -- both without
// holding a second copy. Output returns the bytes when you need them in memory.
err := cr.Save("out.pdf")
_, err = cr.WriteTo(w)  // e.g. an http.ResponseWriter or a bytes.Buffer
b, err := cr.Output()

// For a batch too large to hold every output at once, ConvertEach streams:
// it calls the callback on each result as it completes and closes it for you.
err = gopdfrab.ConvertEach(paths, gopdfrab.PDFA1B, gopdfrab.Options{Workers: 4},
	func(r gopdfrab.FileResult[gopdfrab.ConvertResult]) error {
		if r.Err != nil {
			return nil // skip this file, keep going
		}
		return r.Result.Save(filepath.Join(outDir, filepath.Base(r.Path)))
	})

// Start from the full profile and remove checks
p := gopdfrab.PDFA1B.
	RemoveCheck(gopdfrab.Checks.Structure.FileHeaderSignature).
	RemoveCheck(gopdfrab.Checks.Font.SimpleNotEmbedded)

res, err := doc.Verify(p)

// Or start from an empty profile and add only what you need
p2 := gopdfrab.PDFA1B.Clear().
	AddCheck(
		gopdfrab.Checks.Transparency.ImageWithSoftMask,
		gopdfrab.Checks.Metadata.PDFAIdentifierMissing,
	)

res2, err := doc.Verify(p2)

gopdfrab.AllChecks()                       // every registered check, with names, descriptions, clauses
gopdfrab.CheckByClause("6.3.4", 1)          // a single check by clause + index
gopdfrab.ChecksForClause("6.3.4")           // all checks registered under a clause

for _, issue := range v.Issues {
	c := issue.Check()
	fmt.Println(c.Clause(), c.Subclause(), c.Name(), c.Description())
	fmt.Println(issue.Page(), issue.Messages())
}

fmt.Println(v.Summary())   // human-readable report, one line per Check
v.Checks()                 // distinct Checks violated, sorted by clause
v.IssuesByCheck()          // map[Check][]PDFError
v.IssuesOnPage(1)          // issues found on page 1 (0 = document-level)

// Result, PDFError and Check marshal to a stable JSON shape,
// for CLI, service, or CI integration.
b, err := json.Marshal(v)

// {"type":"A-1b","valid":false,"issueCount":2,"issues":[
//   {"check":{"name":"...","clause":"6.1.3",...},
//    "page":0,"documentLevel":true,"messages":["..."],"text":"..."}]}

ok, err := doc.IsPDFA()   // shorthand for Verify(PDFA1B).Valid

ok, err = doc.IsPDF()     // shorthand for VerifyObjectModel().Valid

part, level, err := doc.ClaimedConformance() // e.g. "1", "B" -- what the file claims, not whether it's valid

n, err := doc.PageCount()   // number of pages

version, err := doc.Version()  // PDF version from the header, e.g. "1.7"

info, err := doc.Metadata()    // Info dictionary entries (Title, Author, ...)

xmp, err := doc.XMPMetadata()  // raw XMP packet bytes, decoded to UTF-8

// Verify against the legacy Isartor-derived profile instead of the
// veraPDF-aligned default
v, err := doc.Verify(gopdfrab.Legacy1B)