Conversão para HTML

O PDF Oxide converte páginas de PDF em HTML estruturado com detecção de títulos, estilização de fontes e preservação opcional de layout via CSS. Use to_html() para uma única página ou to_html_all() para converter o documento inteiro. Com preserve_layout ativado, os elementos são posicionados com coordenadas CSS absolutas, reproduzindo o layout original do PDF. Desativado, a saída é um HTML semântico com fluxo natural.

Exemplo Rápido

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")
html = doc.to_html(0, detect_headings=True)
print(html)

Node.js

const { PdfDocument } = require("pdf-oxide");

const doc = new PdfDocument("report.pdf");
const html = doc.toHtml(0);
console.log(html);
doc.close();

Go

import pdfoxide "github.com/yfedoseev/pdf_oxide/go"

doc, _ := pdfoxide.Open("report.pdf")
defer doc.Close()
html, _ := doc.ToHtml(0)
fmt.Println(html)

C#

using PdfOxide.Core;

using var doc = PdfDocument.Open("report.pdf");
var html = doc.ToHtml(0);
Console.WriteLine(html);

WASM

const doc = new WasmPdfDocument(bytes);
const html = doc.toHtml(0);
console.log(html);

Rust

use pdf_oxide::PdfDocument;
use pdf_oxide::converters::ConversionOptions;

let mut doc = PdfDocument::open("report.pdf")?;
let options = ConversionOptions { detect_headings: true, ..Default::default() };
let html = doc.to_html(0, &options)?;
println!("{}", html);

Java

import fyi.oxide.pdf.PdfDocument;

try (PdfDocument doc = PdfDocument.open(java.nio.file.Path.of("report.pdf"))) {
    String html = doc.toHtml(0);
    System.out.println(html);
}

Kotlin

import fyi.oxide.pdf.PdfDocument

PdfDocument.open(java.nio.file.Path.of("report.pdf")).use { doc ->
    val html = doc.toHtml(0)
    println(html)
}

Scala

import fyi.oxide.pdf.PdfDocument
import scala.util.Using

Using.resource(PdfDocument.open("report.pdf")) { doc =>
  val html = doc.toHtml(0)
  println(html)
}

Clojure

(require '[pdf-oxide.core :as pdf])

(with-open [doc (pdf/open "report.pdf")]
  (println (pdf/to-html doc 0)))

PHP

use PdfOxide\PdfDocument;

$doc = PdfDocument::open('report.pdf');
$html = $doc->toHtml(0);
echo $html;
$doc->close();

Ruby

require 'pdf_oxide'

PdfOxide::PdfDocument.open('report.pdf') do |doc|
  html = doc.to_html(0)
  puts html
end

C++

#include <pdf_oxide/pdf_oxide.hpp>

auto doc = pdf_oxide::Document::open("report.pdf");
auto html = doc.to_html(0);
std::cout << html << std::endl;

Swift

import PdfOxide

let doc = try Document.open("report.pdf")
let html = try doc.toHtml(0)
print(html)

Dart

import 'package:pdf_oxide/pdf_oxide.dart';

final doc = PdfDocument.open('report.pdf');
final html = doc.toHtml(0);
print(html);

R

library(pdfoxide)

doc <- pdf_open("report.pdf")
html <- pdf_to_html(doc, 0)
cat(html)

Julia

using PdfOxide

doc = open_document("report.pdf")
html = to_html(doc, 0)
println(html)

Zig

const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

var doc = try pdf_oxide.Document.open("report.pdf");
const html = try doc.toHtml(a, 0);
std.debug.print("{s}\n", .{html});

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

POXDocument *doc = [POXDocument openPath:@"report.pdf" error:&err];
NSString *html = [doc toHtml:0 error:&err];
NSLog(@"%@", html);

Elixir

{:ok, doc} = PdfOxide.open("report.pdf")
{:ok, html} = PdfOxide.to_html(doc, 0)
IO.puts(html)

---

Referência da API

to_html(page_index, ...) -> str

Converte uma única página para HTML.

Assinatura Python

doc.to_html(
    page: int,
    preserve_layout: bool = False,
    detect_headings: bool = True,
    include_images: bool = True,
    image_output_dir: str | None = None,
    embed_images: bool = True,
) -> str

Assinatura JavaScript

doc.toHtml(pageIndex, preserveLayout?, detectHeadings?, includeFormFields?) -> string

Assinatura Rust

pub fn to_html(
    &mut self,
    page_index: usize,
    options: &ConversionOptions,
) -> Result<String>

Parâmetro	Tipo	Padrão	Descrição
page_index	int / usize / number	–	Índice de página baseado em zero
preserve_layout	bool	false	Usa posicionamento CSS absoluto para reproduzir o layout do PDF
detect_headings	bool	true	Detecta automaticamente níveis de título pelo tamanho da fonte
include_images	bool	true	Inclui imagens na saída HTML
image_output_dir	str / None	None	Diretório para salvar imagens extraídas (apenas Python/Rust)
embed_images	bool	true	Incorpora imagens como data URIs base64 (apenas Python/Rust)
include_form_fields	bool	true	Inclui valores de campos de formulário (Python/JS)

Retorna: String HTML da página.

Com preserve_layout igual a true, a saída usa elementos <div> com posicionamento CSS absoluto:

<div style="position: absolute; left: 72.0px; top: 100.0px; font-size: 24px; font-weight: bold;">
  Introduction
</div>

Com preserve_layout igual a false, a saída usa elementos semânticos:

<h1>Introduction</h1>
<p>This report examines the quarterly results...</p>

---

to_html_all(...) -> str

Converte todas as páginas para HTML. Cada página é envolvida em um elemento <div class="page">.

Assinatura Python

doc.to_html_all(
    preserve_layout: bool = False,
    detect_headings: bool = True,
    include_images: bool = True,
    image_output_dir: str | None = None,
    embed_images: bool = True,
) -> str

Assinatura JavaScript

doc.toHtmlAll(preserveLayout?, detectHeadings?, includeFormFields?) -> string

Assinatura Rust

pub fn to_html_all(
    &mut self,
    options: &ConversionOptions,
) -> Result<String>

Parâmetro	Tipo	Padrão	Descrição
preserve_layout	bool	false	Usa posicionamento CSS absoluto
detect_headings	bool	true	Detecta títulos
include_images	bool	true	Inclui imagens
image_output_dir	str / None	None	Diretório de saída das imagens
embed_images	bool	true	Incorpora imagens como base64

Retorna: String HTML de todas as páginas.

---

ConversionOptions

Consulte a página de Conversão para Markdown para a referência completa de ConversionOptions. A mesma struct de opções é compartilhada entre a conversão para Markdown e para HTML.

---

Exemplos Avançados

Converter todas as páginas para HTML

WASM

const doc = new WasmPdfDocument(bytes);
const html = doc.toHtmlAll(false, true, true);
writeFileSync("report.html", html);
doc.free();

Java

import fyi.oxide.pdf.PdfDocument;
import java.nio.file.*;

try (PdfDocument doc = PdfDocument.open(Path.of("report.pdf"))) {
    String html = doc.toHtml(); // no-arg overload converts the whole document
    Files.writeString(Path.of("report.html"), html);
}

Kotlin

import fyi.oxide.pdf.PdfDocument
import java.nio.file.*

PdfDocument.open(Path.of("report.pdf")).use { doc ->
    val html = doc.toHtml() // whole document
    Files.writeString(Path.of("report.html"), html)
}

Scala

import fyi.oxide.pdf.PdfDocument
import java.nio.file.*
import scala.util.Using

Using.resource(PdfDocument.open("report.pdf")) { doc =>
  val html = doc.toHtml() // whole document
  Files.writeString(Path.of("report.html"), html)
}

Clojure

(require '[pdf-oxide.core :as pdf])
(require '[clojure.java.io :as io])

(with-open [doc (pdf/open "report.pdf")]
  (spit "report.html" (pdf/to-html doc))) ; whole document

Ruby

require 'pdf_oxide'

PdfOxide::PdfDocument.open('report.pdf') do |doc|
  html = doc.to_html # whole document
  File.write('report.html', html)
end

C++

#include <pdf_oxide/pdf_oxide.hpp>
#include <fstream>

auto doc = pdf_oxide::Document::open("report.pdf");
auto html = doc.to_html_all();
std::ofstream("report.html") << html;

Swift

import PdfOxide

let doc = try Document.open("report.pdf")
let html = try doc.toHtmlAll()
try html.write(toFile: "report.html", atomically: true, encoding: .utf8)

Dart

import 'dart:io';
import 'package:pdf_oxide/pdf_oxide.dart';

final doc = PdfDocument.open('report.pdf');
final html = doc.toHtmlAll();
File('report.html').writeAsStringSync(html);

R

library(pdfoxide)

doc <- pdf_open("report.pdf")
html <- pdf_to_html_all(doc)
writeLines(html, "report.html")

Julia

using PdfOxide

doc = open_document("report.pdf")
html = to_html_all(doc)
write("report.html", html)

Zig

const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

var doc = try pdf_oxide.Document.open("report.pdf");
const html = try doc.toHtmlAll(a);
try std.fs.cwd().writeFile(.{ .sub_path = "report.html", .data = html });

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

POXDocument *doc = [POXDocument openPath:@"report.pdf" error:&err];
NSString *html = [doc toHtmlAllWithError:&err];
[html writeToFile:@"report.html" atomically:YES encoding:NSUTF8StringEncoding error:&err];

Elixir

{:ok, doc} = PdfOxide.open("report.pdf")
{:ok, html} = PdfOxide.to_html_all(doc)
File.write!("report.html", html)

Criar um arquivo HTML completo

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")
body = doc.to_html_all(detect_headings=True)

html = f"""<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Report</title>
    <style>
        body {{ font-family: sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; }}
        .page {{ margin-bottom: 2rem; border-bottom: 1px solid #ccc; padding-bottom: 2rem; }}
    </style>
</head>
<body>
{body}
</body>
</html>"""

with open("report.html", "w", encoding="utf-8") as f:
    f.write(html)

HTML com layout preservado para fidelidade visual

use pdf_oxide::PdfDocument;
use pdf_oxide::converters::ConversionOptions;

let mut doc = PdfDocument::open("brochure.pdf")?;
let options = ConversionOptions {
    preserve_layout: true,
    detect_headings: false, // layout mode uses exact positioning
    include_images: true,
    embed_images: true,
    ..Default::default()
};

let html = doc.to_html(0, &options)?;
std::fs::write("brochure.html", &html)?;

Converter com arquivos de imagem externos

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")
html = doc.to_html_all(
    detect_headings=True,
    include_images=True,
    embed_images=False,
    image_output_dir="output/images",
)

with open("output/report.html", "w") as f:
    f.write(html)
# Images saved as output/images/img_001.png, img_002.jpg, etc.

Conversão página por página com wrappers personalizados

use pdf_oxide::PdfDocument;
use pdf_oxide::converters::ConversionOptions;

let mut doc = PdfDocument::open("book.pdf")?;
let options = ConversionOptions::default();
let page_count = doc.page_count()?;

let mut pages_html = Vec::new();
for i in 0..page_count {
    let html = doc.to_html(i, &options)?;
    pages_html.push(format!(
        "<section id=\"page-{}\" class=\"page\">\n{}\n</section>",
        i + 1, html
    ));
}

let full = pages_html.join("\n");
std::fs::write("output.html", &full)?;

---

Páginas Relacionadas

• Conversão para Markdown – Converter para Markdown em vez de HTML
• Extração de Texto – Extrair texto puro sem formatação
• Extração de Imagens – Extrair imagens separadamente