What is the fastest Python PDF library?

PDF Oxide is the fastest Python PDF library, with 0.8ms mean text extraction time — 5.8× faster than PyMuPDF (4.6ms) and 15× faster than pypdf (12.1ms). Benchmarked on 3,830 real-world PDFs with 100% pass rate.

Is PDF Oxide free for commercial use?

Yes. PDF Oxide is MIT licensed — free for all uses including commercial products, SaaS, and proprietary software. No license fees, no sales calls, no AGPL restrictions.

Can PDF Oxide handle scanned PDFs with OCR?

Yes. PDF Oxide includes built-in OCR via PaddleOCR and ONNX Runtime. No Tesseract installation needed — just pip install pdf_oxide and use extract_text_ocr(). Supports PP-OCRv3, v4, and v5 models.

Does PDF Oxide support XFA forms?

Yes. PDF Oxide is the only Python PDF library that can detect, analyze, and extract data from XFA forms (XML Forms Architecture). PyMuPDF, pypdf, pdfplumber, and pdfminer cannot read XFA form data.

How does PDF Oxide compare to PyMuPDF?

PDF Oxide is 5.8× faster than PyMuPDF (0.8ms vs 4.6ms mean), has a 100% pass rate vs 99.3%, and is MIT licensed vs PyMuPDF's AGPL-3.0. PDF Oxide also has built-in Markdown/HTML output and XFA form support that PyMuPDF lacks.

Can PDF Oxide convert PDF to Markdown?

Yes. PDF Oxide has built-in PDF to Markdown conversion with heading detection, table preservation, and list formatting — ideal for LLM and RAG pipelines. No separate package needed, unlike PyMuPDF which requires pymupdf4llm (69× slower).

Converter PDF e documentos Office nos dois sentidos

Converta documentos do Microsoft Office (Word, Excel, PowerPoint) para PDF — e converta um PDF de volta para DOCX, PPTX ou XLSX — sem precisar do Microsoft Office ou do LibreOffice instalado. O PDF Oxide analisa o formato OOXML diretamente e gera a saída em PDF, além de renderizar páginas PDF de volta em documentos Office editáveis.

A conversão funciona em dois sentidos:

Office → PDF — a classe OfficeConverter (e os construtores open_from_*_bytes) analisa DOCX/XLSX/PPTX e gera um PDF.
PDF → Office — os métodos to_docx / to_pptx / to_xlsx em um documento aberto exportam de volta para os formatos Office.

Exemplo rápido

Python

from pdf_oxide import OfficeConverter

# Auto-detect format from extension
pdf = OfficeConverter.convert("report.docx")
pdf.save("report.pdf")

Rust

use pdf_oxide::converters::office::OfficeConverter;

let converter = OfficeConverter::new();
let pdf_bytes = converter.convert("report.docx")?;
std::fs::write("report.pdf", pdf_bytes)?;

C++

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

std::ifstream in("report.docx", std::ios::binary);
std::vector<std::uint8_t> docx((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_docx_bytes(docx);
auto pdf = doc.get_source_bytes();
std::ofstream("report.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());

Dart

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

final docx = File('report.docx').readAsBytesSync();
final doc = PdfDocument.openFromDocxBytes(docx);
File('report.pdf').writeAsBytesSync(doc.getSourceBytes());

library(pdfoxide)

docx <- readBin("report.docx", "raw", file.info("report.docx")$size)
doc  <- pdf_open_from_docx_bytes(docx)
writeBin(pdf_get_source_bytes(doc), "report.pdf")

Julia

using PdfOxide

docx = read("report.docx")
doc  = open_from_docx_bytes(docx)
write("report.pdf", get_source_bytes(doc))

Zig

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

const docx = try std.fs.cwd().readFileAlloc("report.docx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromDocxBytes(docx);
const pdf = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "report.pdf", .data = pdf });

Objective-C

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

NSData *docx = [NSData dataWithContentsOfFile:@"report.docx"];
POXDocument *doc = [POXDocument openFromDocxBytes:docx error:&err];
NSData *pdf = [doc sourceBytesWithError:&err];
[pdf writeToFile:@"report.pdf" atomically:YES];

Elixir

docx = File.read!("report.docx")
{:ok, doc} = PdfOxide.open_from_docx_bytes(docx)
{:ok, pdf} = PdfOxide.source_bytes(doc)
File.write!("report.pdf", pdf)

Formatos suportados

Formato	Extensão	Descrição
DOCX	`.docx`	Documentos Word — parágrafos, títulos, listas, formatação de texto
XLSX	`.xlsx`, `.xls`	Planilhas Excel — múltiplas abas, largura de coluna automática, tipos de célula
PPTX	`.pptx`	Apresentações PowerPoint — slides, títulos, caixas de texto

Documentos Word (DOCX)

Converta documentos Word preservando títulos, parágrafos, listas e formatação de texto (negrito, itálico, sublinhado, cores, tamanhos de fonte).

Python

from pdf_oxide import OfficeConverter

pdf = OfficeConverter.from_docx("document.docx")
pdf.save("document.pdf")

Rust

use pdf_oxide::converters::office::OfficeConverter;

let converter = OfficeConverter::new();
let pdf_bytes = converter.convert_docx("document.docx")?;
std::fs::write("document.pdf", pdf_bytes)?;

C++

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

std::ifstream in("document.docx", std::ios::binary);
std::vector<std::uint8_t> docx((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_docx_bytes(docx);
auto pdf = doc.get_source_bytes();
std::ofstream("document.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());

Dart

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

final docx = File('document.docx').readAsBytesSync();
final doc = PdfDocument.openFromDocxBytes(docx);
File('document.pdf').writeAsBytesSync(doc.getSourceBytes());

library(pdfoxide)

docx <- readBin("document.docx", "raw", file.info("document.docx")$size)
doc  <- pdf_open_from_docx_bytes(docx)
writeBin(pdf_get_source_bytes(doc), "document.pdf")

Julia

using PdfOxide

docx = read("document.docx")
doc  = open_from_docx_bytes(docx)
write("document.pdf", get_source_bytes(doc))

Zig

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

const docx = try std.fs.cwd().readFileAlloc("document.docx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromDocxBytes(docx);
const pdf = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "document.pdf", .data = pdf });

Objective-C

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

NSData *docx = [NSData dataWithContentsOfFile:@"document.docx"];
POXDocument *doc = [POXDocument openFromDocxBytes:docx error:&err];
NSData *pdf = [doc sourceBytesWithError:&err];
[pdf writeToFile:@"document.pdf" atomically:YES];

Elixir

docx = File.read!("document.docx")
{:ok, doc} = PdfOxide.open_from_docx_bytes(docx)
{:ok, pdf} = PdfOxide.source_bytes(doc)
File.write!("document.pdf", pdf)

A partir de bytes

Python

from pdf_oxide import OfficeConverter

with open("document.docx", "rb") as f:
    pdf = OfficeConverter.from_docx_bytes(f.read())
pdf.save("document.pdf")

Rust

let docx_bytes = std::fs::read("document.docx")?;
let converter = OfficeConverter::new();
let pdf_bytes = converter.convert_docx_bytes(&docx_bytes)?;
std::fs::write("document.pdf", pdf_bytes)?;

C++

std::ifstream in("document.docx", std::ios::binary);
std::vector<std::uint8_t> docx_bytes((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_docx_bytes(docx_bytes);
auto pdf_bytes = doc.get_source_bytes();
std::ofstream("document.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf_bytes.data()), pdf_bytes.size());

Dart

final docxBytes = File('document.docx').readAsBytesSync();
final doc = PdfDocument.openFromDocxBytes(docxBytes);
File('document.pdf').writeAsBytesSync(doc.getSourceBytes());

docx_bytes <- readBin("document.docx", "raw", file.info("document.docx")$size)
doc <- pdf_open_from_docx_bytes(docx_bytes)
writeBin(pdf_get_source_bytes(doc), "document.pdf")

Julia

docx_bytes = read("document.docx")
doc = open_from_docx_bytes(docx_bytes)
write("document.pdf", get_source_bytes(doc))

Zig

const docx_bytes = try std.fs.cwd().readFileAlloc("document.docx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromDocxBytes(docx_bytes);
const pdf_bytes = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "document.pdf", .data = pdf_bytes });

Objective-C

NSData *docxBytes = [NSData dataWithContentsOfFile:@"document.docx"];
POXDocument *doc = [POXDocument openFromDocxBytes:docxBytes error:&err];
NSData *pdfBytes = [doc sourceBytesWithError:&err];
[pdfBytes writeToFile:@"document.pdf" atomically:YES];

Elixir

docx_bytes = File.read!("document.docx")
{:ok, doc} = PdfOxide.open_from_docx_bytes(docx_bytes)
{:ok, pdf_bytes} = PdfOxide.source_bytes(doc)
File.write!("document.pdf", pdf_bytes)

Recursos DOCX suportados

Parágrafos com alinhamento (esquerda, centro, direita, justificado)
Títulos (estilos Título 1–9)
Formatação de texto: negrito, itálico, sublinhado, tachado
Tamanhos e cores de fonte
Listas numeradas e com marcadores, com aninhamento
Extração de metadados (título e autor de docProps/core.xml)

Planilhas Excel (XLSX)

Converta planilhas para PDF com cálculo automático da largura das colunas e suporte a múltiplas abas. Cada aba é renderizada como uma seção separada.

Python

from pdf_oxide import OfficeConverter

pdf = OfficeConverter.from_xlsx("data.xlsx")
pdf.save("data.pdf")

Rust

let converter = OfficeConverter::new();
let pdf_bytes = converter.convert_xlsx("data.xlsx")?;
std::fs::write("data.pdf", pdf_bytes)?;

C++

std::ifstream in("data.xlsx", std::ios::binary);
std::vector<std::uint8_t> xlsx((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_xlsx_bytes(xlsx);
auto pdf = doc.get_source_bytes();
std::ofstream("data.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());

Dart

final xlsx = File('data.xlsx').readAsBytesSync();
final doc = PdfDocument.openFromXlsxBytes(xlsx);
File('data.pdf').writeAsBytesSync(doc.getSourceBytes());

xlsx <- readBin("data.xlsx", "raw", file.info("data.xlsx")$size)
doc  <- pdf_open_from_xlsx_bytes(xlsx)
writeBin(pdf_get_source_bytes(doc), "data.pdf")

Julia

xlsx = read("data.xlsx")
doc  = open_from_xlsx_bytes(xlsx)
write("data.pdf", get_source_bytes(doc))

Zig

const xlsx = try std.fs.cwd().readFileAlloc("data.xlsx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromXlsxBytes(xlsx);
const pdf = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "data.pdf", .data = pdf });

Objective-C

NSData *xlsx = [NSData dataWithContentsOfFile:@"data.xlsx"];
POXDocument *doc = [POXDocument openFromXlsxBytes:xlsx error:&err];
NSData *pdf = [doc sourceBytesWithError:&err];
[pdf writeToFile:@"data.pdf" atomically:YES];

Elixir

xlsx = File.read!("data.xlsx")
{:ok, doc} = PdfOxide.open_from_xlsx_bytes(xlsx)
{:ok, pdf} = PdfOxide.source_bytes(doc)
File.write!("data.pdf", pdf)

Recursos XLSX suportados

Renderização de múltiplas abas com títulos
Tipos de célula: strings, inteiros, decimais, booleanos, datas, erros
Cálculo automático da largura das colunas
Quebras de página automáticas quando o conteúdo excede o espaço disponível

Apresentações PowerPoint (PPTX)

Converta apresentações para PDF. Cada slide vira uma página com títulos e caixas de texto extraídos.

Python

from pdf_oxide import OfficeConverter

pdf = OfficeConverter.from_pptx("slides.pptx")
pdf.save("slides.pdf")

Rust

let converter = OfficeConverter::new();
let pdf_bytes = converter.convert_pptx("slides.pptx")?;
std::fs::write("slides.pdf", pdf_bytes)?;

C++

std::ifstream in("slides.pptx", std::ios::binary);
std::vector<std::uint8_t> pptx((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_pptx_bytes(pptx);
auto pdf = doc.get_source_bytes();
std::ofstream("slides.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());

Dart

final pptx = File('slides.pptx').readAsBytesSync();
final doc = PdfDocument.openFromPptxBytes(pptx);
File('slides.pdf').writeAsBytesSync(doc.getSourceBytes());

pptx <- readBin("slides.pptx", "raw", file.info("slides.pptx")$size)
doc  <- pdf_open_from_pptx_bytes(pptx)
writeBin(pdf_get_source_bytes(doc), "slides.pdf")

Julia

pptx = read("slides.pptx")
doc  = open_from_pptx_bytes(pptx)
write("slides.pdf", get_source_bytes(doc))

Zig

const pptx = try std.fs.cwd().readFileAlloc("slides.pptx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromPptxBytes(pptx);
const pdf = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "slides.pdf", .data = pdf });

Objective-C

NSData *pptx = [NSData dataWithContentsOfFile:@"slides.pptx"];
POXDocument *doc = [POXDocument openFromPptxBytes:pptx error:&err];
NSData *pdf = [doc sourceBytesWithError:&err];
[pdf writeToFile:@"slides.pdf" atomically:YES];

Elixir

pptx = File.read!("slides.pptx")
{:ok, doc} = PdfOxide.open_from_pptx_bytes(pptx)
{:ok, pdf} = PdfOxide.source_bytes(doc)
File.write!("slides.pdf", pdf)

Como converter um PDF para DOCX, PPTX ou XLSX?

O sentido inverso — PDF → Office — funciona a partir de um documento PDF aberto, não do OfficeConverter. Abra um PDF com PdfDocument (Python/Rust), OpenFromBytes/Open (Go/C#) ou Document.open (Swift) e chame to_docx / to_pptx / to_xlsx para exportar para os formatos Office.

O PDF Oxide escolhe a estratégia de emissão automaticamente com base na contagem de páginas: documentos no limite de layout ou abaixo dele (30 páginas para DOCX/PPTX, 200 para XLSX) usam o caminho de preservação de layout, que mantém cada trecho de texto próximo à sua posição original; documentos maiores recorrem ao caminho de fluxo, que reorganiza o conteúdo para que o Word/PowerPoint/Excel abra instantaneamente. Cada página PDF vira uma seção DOCX, um slide PPTX ou uma planilha XLSX, e as dimensões da página original e as fontes incorporadas são preservadas para que uma ida e volta PDF → Office → PDF mantenha o layout original.

PDF para Word (DOCX)

Rust

use pdf_oxide::document::PdfDocument;

let doc = PdfDocument::open("report.pdf")?;

// Write straight to disk
doc.to_docx("report.docx")?;

// Or get the bytes in memory
let docx_bytes: Vec<u8> = doc.to_docx_bytes()?;
std::fs::write("report.docx", docx_bytes)?;

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")

# Write straight to disk
doc.to_docx("report.docx")

# Or get the bytes in memory
docx_bytes = doc.to_docx_bytes()
with open("report.docx", "wb") as f:
    f.write(docx_bytes)

doc, err := pdfoxide.Open("report.pdf")
if err != nil {
    log.Fatal(err)
}
defer doc.Close()

docxBytes, err := doc.ToDocxBytes()
if err != nil {
    log.Fatal(err)
}
os.WriteFile("report.docx", docxBytes, 0o644)

using PdfOxide.Core;

using var doc = PdfDocument.Open("report.pdf");
byte[] docxBytes = doc.ToDocxBytes();
File.WriteAllBytes("report.docx", docxBytes);

Swift

import PdfOxide

let doc = try Document.open("report.pdf")
let docxBytes = try doc.toDocx()
try Data(docxBytes).write(to: URL(fileURLWithPath: "report.docx"))

C++

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

auto doc = pdf_oxide::Document::open("report.pdf");
auto docx_bytes = doc.to_docx();
std::ofstream("report.docx", std::ios::binary)
    .write(reinterpret_cast<const char*>(docx_bytes.data()), docx_bytes.size());

Dart

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

final doc = PdfDocument.open('report.pdf');
File('report.docx').writeAsBytesSync(doc.toDocx());

library(pdfoxide)

doc <- pdf_open("report.pdf")
writeBin(pdf_to_docx(doc), "report.docx")

Julia

using PdfOxide

doc = open_document("report.pdf")
write("report.docx", to_docx(doc))

Zig

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

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

Objective-C

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

POXDocument *doc = [POXDocument openPath:@"report.pdf" error:&err];
NSData *docxBytes = [doc toDocxWithError:&err];
[docxBytes writeToFile:@"report.docx" atomically:YES];

Elixir

{:ok, doc} = PdfOxide.open("report.pdf")
{:ok, docx_bytes} = PdfOxide.to_docx(doc)
File.write!("report.docx", docx_bytes)

PDF para PowerPoint (PPTX)

Rust

use pdf_oxide::document::PdfDocument;

let doc = PdfDocument::open("deck.pdf")?;
doc.to_pptx("deck.pptx")?;            // to disk
let pptx_bytes = doc.to_pptx_bytes()?; // or in memory

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("deck.pdf")
doc.to_pptx("deck.pptx")           # to disk
pptx_bytes = doc.to_pptx_bytes()   # or in memory

doc, _ := pdfoxide.Open("deck.pdf")
defer doc.Close()
pptxBytes, err := doc.ToPptxBytes()
if err != nil {
    log.Fatal(err)
}
os.WriteFile("deck.pptx", pptxBytes, 0o644)

using var doc = PdfDocument.Open("deck.pdf");
File.WriteAllBytes("deck.pptx", doc.ToPptxBytes());

Swift

let doc = try Document.open("deck.pdf")
let pptxBytes = try doc.toPptx()
try Data(pptxBytes).write(to: URL(fileURLWithPath: "deck.pptx"))

C++

auto doc = pdf_oxide::Document::open("deck.pdf");
auto pptx_bytes = doc.to_pptx();
std::ofstream("deck.pptx", std::ios::binary)
    .write(reinterpret_cast<const char*>(pptx_bytes.data()), pptx_bytes.size());

Dart

final doc = PdfDocument.open('deck.pdf');
File('deck.pptx').writeAsBytesSync(doc.toPptx());

doc <- pdf_open("deck.pdf")
writeBin(pdf_to_pptx(doc), "deck.pptx")

Julia

doc = open_document("deck.pdf")
write("deck.pptx", to_pptx(doc))

Zig

var doc = try pdf_oxide.Document.open("deck.pdf");
const pptx_bytes = try doc.toPptx(a);
try std.fs.cwd().writeFile(.{ .sub_path = "deck.pptx", .data = pptx_bytes });

Objective-C

POXDocument *doc = [POXDocument openPath:@"deck.pdf" error:&err];
NSData *pptxBytes = [doc toPptxWithError:&err];
[pptxBytes writeToFile:@"deck.pptx" atomically:YES];

Elixir

{:ok, doc} = PdfOxide.open("deck.pdf")
{:ok, pptx_bytes} = PdfOxide.to_pptx(doc)
File.write!("deck.pptx", pptx_bytes)

PDF para Excel (XLSX)

Rust

use pdf_oxide::document::PdfDocument;

let doc = PdfDocument::open("table.pdf")?;
doc.to_xlsx("table.xlsx")?;            // to disk
let xlsx_bytes = doc.to_xlsx_bytes()?; // or in memory

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("table.pdf")
doc.to_xlsx("table.xlsx")          # to disk
xlsx_bytes = doc.to_xlsx_bytes()   # or in memory

doc, _ := pdfoxide.Open("table.pdf")
defer doc.Close()
xlsxBytes, err := doc.ToXlsxBytes()
if err != nil {
    log.Fatal(err)
}
os.WriteFile("table.xlsx", xlsxBytes, 0o644)

using var doc = PdfDocument.Open("table.pdf");
File.WriteAllBytes("table.xlsx", doc.ToXlsxBytes());

Swift

let doc = try Document.open("table.pdf")
let xlsxBytes = try doc.toXlsx()
try Data(xlsxBytes).write(to: URL(fileURLWithPath: "table.xlsx"))

C++

auto doc = pdf_oxide::Document::open("table.pdf");
auto xlsx_bytes = doc.to_xlsx();
std::ofstream("table.xlsx", std::ios::binary)
    .write(reinterpret_cast<const char*>(xlsx_bytes.data()), xlsx_bytes.size());

Dart

final doc = PdfDocument.open('table.pdf');
File('table.xlsx').writeAsBytesSync(doc.toXlsx());

doc <- pdf_open("table.pdf")
writeBin(pdf_to_xlsx(doc), "table.xlsx")

Julia

doc = open_document("table.pdf")
write("table.xlsx", to_xlsx(doc))

Zig

var doc = try pdf_oxide.Document.open("table.pdf");
const xlsx_bytes = try doc.toXlsx(a);
try std.fs.cwd().writeFile(.{ .sub_path = "table.xlsx", .data = xlsx_bytes });

Objective-C

POXDocument *doc = [POXDocument openPath:@"table.pdf" error:&err];
NSData *xlsxBytes = [doc toXlsxWithError:&err];
[xlsxBytes writeToFile:@"table.xlsx" atomically:YES];

Elixir

{:ok, doc} = PdfOxide.open("table.pdf")
{:ok, xlsx_bytes} = PdfOxide.to_xlsx(doc)
File.write!("table.xlsx", xlsx_bytes)

Observação para Python: to_docx/to_pptx/to_xlsx estão disponíveis em PdfDocument (a classe de extração/inspeção), não no construtor OfficeConverter/Pdf usado para a direção Office → PDF. Use PdfDocument("file.pdf") para abrir o PDF de origem.

Como abrir um arquivo Office diretamente como documento PDF?

Os bindings nativos (Go, C#, Swift e o C ABI) expõem construtores open_from_*_bytes que convertem bytes DOCX/PPTX/XLSX e devolvem um PdfDocument já aberto — prático quando você quer extrair texto, renderizar ou reexportar imediatamente sem salvar o PDF intermediário. Cada construtor executa o OfficeConverter internamente e abre o PDF resultante em uma única chamada.

data, err := os.ReadFile("contract.docx")
if err != nil {
    log.Fatal(err)
}

doc, err := pdfoxide.OpenFromDocxBytes(data)
if err != nil {
    log.Fatal(err)
}
defer doc.Close()

// Now work with it as a normal PDF document
text, _ := doc.ExtractText(0)
fmt.Println(text)

using PdfOxide.Core;

byte[] data = File.ReadAllBytes("contract.docx");
using var doc = PdfDocument.OpenFromDocxBytes(data);

// Use it like any other open PDF — extract, render, or re-export
byte[] pdfBytes = doc.ToDocxBytes(); // round-trip if you like

Swift

import PdfOxide
import Foundation

let data = try Data(contentsOf: URL(fileURLWithPath: "contract.docx"))
let doc = try Document.openFromDocxBytes([UInt8](data))
let pageCount = try doc.pageCount()
print("Converted DOCX has \(pageCount) page(s)")

C++

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

std::ifstream in("contract.docx", std::ios::binary);
std::vector<std::uint8_t> data((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_docx_bytes(data);
// Now work with it as a normal PDF document
auto text = doc.extract_text(0);

Dart

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

final data = File('contract.docx').readAsBytesSync();
final doc = PdfDocument.openFromDocxBytes(data);
final text = doc.extractText(0);

library(pdfoxide)

data <- readBin("contract.docx", "raw", file.info("contract.docx")$size)
doc  <- pdf_open_from_docx_bytes(data)
text <- pdf_extract_text(doc, 0)

Julia

using PdfOxide

data = read("contract.docx")
doc  = open_from_docx_bytes(data)
text = extract_text(doc, 0)

Zig

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

const data = try std.fs.cwd().readFileAlloc("contract.docx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromDocxBytes(data);
const text = try doc.extractText(a, 0);

Objective-C

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

NSData *data = [NSData dataWithContentsOfFile:@"contract.docx"];
POXDocument *doc = [POXDocument openFromDocxBytes:data error:&err];
NSString *text = [doc extractText:0 error:&err];

Elixir

data = File.read!("contract.docx")
{:ok, doc} = PdfOxide.open_from_docx_bytes(data)
{:ok, text} = PdfOxide.extract_text(doc, 0)

PPTX e XLSX usam os construtores correspondentes:

Formato de origem	Go	C#	Swift
DOCX	`OpenFromDocxBytes(data)`	`PdfDocument.OpenFromDocxBytes(data)`	`Document.openFromDocxBytes(bytes)`
PPTX	`OpenFromPptxBytes(data)`	`PdfDocument.OpenFromPptxBytes(data)`	`Document.openFromPptxBytes(bytes)`
XLSX	`OpenFromXlsxBytes(data)`	`PdfDocument.OpenFromXlsxBytes(data)`	`Document.openFromXlsxBytes(bytes)`

Rust / Python: o PdfDocument do núcleo não tem o construtor open_from_docx_bytes. Em Rust, converta primeiro com OfficeConverter::new().convert_docx_bytes(&data)? e depois abra com PdfDocument::from_bytes(pdf_bytes)?. Em Python, use OfficeConverter.from_docx_bytes(data) (documentado acima), que retorna um Pdf.

use pdf_oxide::converters::office::OfficeConverter;
use pdf_oxide::document::PdfDocument;

let data = std::fs::read("contract.docx")?;
let pdf_bytes = OfficeConverter::new().convert_docx_bytes(&data)?;
let doc = PdfDocument::from_bytes(pdf_bytes)?;
println!("{} pages", doc.page_count()?);

Configuração (Rust)

Personalize o tamanho da página, as margens e as fontes com OfficeConfig:

use pdf_oxide::converters::office::{OfficeConverter, OfficeConfig};

let config = OfficeConfig::a4(); // A4 page size
let converter = OfficeConverter::with_config(config);
let pdf_bytes = converter.convert_docx("document.docx")?;

Campos de OfficeConfig

Campo	Tipo	Padrão	Descrição
`page_size`	`PageSize`	Letter	Dimensões da página
`margins`	`Margins`	1 polegada em todos os lados	Margens da página em pontos (72pt = 1 polegada)
`embed_fonts`	`bool`	`false`	Se deve incorporar fontes
`default_font`	`String`	`"Helvetica"`	Fonte de fallback
`default_font_size`	`f32`	`11.0`	Tamanho padrão do texto em pontos
`line_height`	`f32`	`1.2`	Multiplicador de altura de linha
`include_images`	`bool`	`true`	Se deve incluir imagens incorporadas

Predefinições de tamanho de página

let config = OfficeConfig::letter(); // 8.5 × 11 inches (default)
let config = OfficeConfig::a4();     // 210 × 297 mm

Margens personalizadas

use pdf_oxide::converters::office::Margins;

let mut config = OfficeConfig::letter();
config.margins = Margins::uniform(36.0);  // 0.5 inch margins
config.margins = Margins::none();          // No margins

Conversão em lote

Python

from pdf_oxide import OfficeConverter
from pathlib import Path

office_dir = Path("documents/")
output_dir = Path("pdfs/")
output_dir.mkdir(exist_ok=True)

extensions = {".docx", ".xlsx", ".pptx"}

for doc_path in office_dir.iterdir():
    if doc_path.suffix.lower() in extensions:
        pdf = OfficeConverter.convert(str(doc_path))
        pdf.save(str(output_dir / doc_path.with_suffix(".pdf").name))
        print(f"Converted: {doc_path.name}")

Rust

use pdf_oxide::converters::office::OfficeConverter;
use std::fs;

let converter = OfficeConverter::new();

for entry in fs::read_dir("documents/")? {
    let path = entry?.path();
    match path.extension().and_then(|e| e.to_str()) {
        Some("docx" | "xlsx" | "pptx") => {
            let pdf_bytes = converter.convert(&path)?;
            let out = format!("pdfs/{}.pdf", path.file_stem().unwrap().to_str().unwrap());
            fs::write(&out, pdf_bytes)?;
            println!("Converted: {}", path.display());
        }
        _ => {}
    }
}

C++

#include <pdf_oxide/pdf_oxide.hpp>
#include <filesystem>
#include <fstream>
namespace fs = std::filesystem;

for (const auto& entry : fs::directory_iterator("documents/")) {
    auto path = entry.path();
    auto ext = path.extension().string();

    if (ext != ".docx" && ext != ".xlsx" && ext != ".pptx") continue;

    std::ifstream in(path, std::ios::binary);
    std::vector<std::uint8_t> bytes((std::istreambuf_iterator<char>(in)), {});

    auto doc =
        ext == ".docx" ? pdf_oxide::Document::open_from_docx_bytes(bytes)
        : ext == ".xlsx" ? pdf_oxide::Document::open_from_xlsx_bytes(bytes)
                         : pdf_oxide::Document::open_from_pptx_bytes(bytes);

    auto pdf = doc.get_source_bytes();
    auto out = "pdfs/" + path.stem().string() + ".pdf";
    std::ofstream(out, std::ios::binary)
        .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());
}

Dart

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

Directory('pdfs').createSync(recursive: true);

for (final entry in Directory('documents').listSync()) {
  if (entry is! File) continue;
  final ext = entry.path.split('.').last.toLowerCase();
  final bytes = entry.readAsBytesSync();

  final doc = switch (ext) {
    'docx' => PdfDocument.openFromDocxBytes(bytes),
    'xlsx' => PdfDocument.openFromXlsxBytes(bytes),
    'pptx' => PdfDocument.openFromPptxBytes(bytes),
    _ => null,
  };
  if (doc == null) continue;

  final name = entry.uri.pathSegments.last.replaceAll(RegExp(r'\.\w+$'), '');
  File('pdfs/$name.pdf').writeAsBytesSync(doc.getSourceBytes());
}

library(pdfoxide)

dir.create("pdfs", showWarnings = FALSE)

for (path in list.files("documents", full.names = TRUE)) {
  ext   <- tolower(tools::file_ext(path))
  bytes <- readBin(path, "raw", file.info(path)$size)

  doc <- switch(ext,
    docx = pdf_open_from_docx_bytes(bytes),
    xlsx = pdf_open_from_xlsx_bytes(bytes),
    pptx = pdf_open_from_pptx_bytes(bytes),
    next)

  out <- file.path("pdfs", paste0(tools::file_path_sans_ext(basename(path)), ".pdf"))
  writeBin(pdf_get_source_bytes(doc), out)
}

Julia

using PdfOxide

mkpath("pdfs")

for path in readdir("documents"; join = true)
    ext   = lowercase(splitext(path)[2])
    bytes = read(path)

    doc = if ext == ".docx"
        open_from_docx_bytes(bytes)
    elseif ext == ".xlsx"
        open_from_xlsx_bytes(bytes)
    elseif ext == ".pptx"
        open_from_pptx_bytes(bytes)
    else
        continue
    end

    name = first(splitext(basename(path)))
    write(joinpath("pdfs", name * ".pdf"), get_source_bytes(doc))
end

Zig

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

try std.fs.cwd().makePath("pdfs");
var dir = try std.fs.cwd().openDir("documents", .{ .iterate = true });
var it = dir.iterate();
while (try it.next()) |entry| {
    const bytes = try dir.readFileAlloc(entry.name, a, .unlimited);

    var doc = if (std.mem.endsWith(u8, entry.name, ".docx"))
        try pdf_oxide.Document.openFromDocxBytes(bytes)
    else if (std.mem.endsWith(u8, entry.name, ".xlsx"))
        try pdf_oxide.Document.openFromXlsxBytes(bytes)
    else if (std.mem.endsWith(u8, entry.name, ".pptx"))
        try pdf_oxide.Document.openFromPptxBytes(bytes)
    else
        continue;

    const pdf = try doc.sourceBytes(a);
    const stem = entry.name[0 .. std.mem.lastIndexOfScalar(u8, entry.name, '.').?];
    const out = try std.fmt.allocPrint(a, "pdfs/{s}.pdf", .{stem});
    try std.fs.cwd().writeFile(.{ .sub_path = out, .data = pdf });
}

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;
NSFileManager *fm = [NSFileManager defaultManager];
[fm createDirectoryAtPath:@"pdfs" withIntermediateDirectories:YES attributes:nil error:&err];

for (NSString *name in [fm contentsOfDirectoryAtPath:@"documents" error:&err]) {
    NSString *path = [@"documents" stringByAppendingPathComponent:name];
    NSData *bytes = [NSData dataWithContentsOfFile:path];
    NSString *ext = name.pathExtension.lowercaseString;

    POXDocument *doc;
    if ([ext isEqualToString:@"docx"])      doc = [POXDocument openFromDocxBytes:bytes error:&err];
    else if ([ext isEqualToString:@"xlsx"]) doc = [POXDocument openFromXlsxBytes:bytes error:&err];
    else if ([ext isEqualToString:@"pptx"]) doc = [POXDocument openFromPptxBytes:bytes error:&err];
    else continue;

    NSData *pdf = [doc sourceBytesWithError:&err];
    NSString *out = [@"pdfs" stringByAppendingPathComponent:
        [name.stringByDeletingPathExtension stringByAppendingPathExtension:@"pdf"]];
    [pdf writeToFile:out atomically:YES];
}

Elixir

File.mkdir_p!("pdfs")

for name <- File.ls!("documents") do
  bytes = File.read!(Path.join("documents", name))

  result =
    case Path.extname(name) |> String.downcase() do
      ".docx" -> PdfOxide.open_from_docx_bytes(bytes)
      ".xlsx" -> PdfOxide.open_from_xlsx_bytes(bytes)
      ".pptx" -> PdfOxide.open_from_pptx_bytes(bytes)
      _ -> :skip
    end

  with {:ok, doc} <- result,
       {:ok, pdf} <- PdfOxide.source_bytes(doc) do
    out = Path.join("pdfs", Path.rootname(name) <> ".pdf")
    File.write!(out, pdf)
  end
end

Referência de API

Python — OfficeConverter

Método	Retorna	Descrição
`OfficeConverter.convert(path)`	`Pdf`	Detecta o formato automaticamente e converte
`OfficeConverter.from_docx(path)`	`Pdf`	Converte arquivo DOCX
`OfficeConverter.from_docx_bytes(data)`	`Pdf`	Converte DOCX a partir de bytes
`OfficeConverter.from_xlsx(path)`	`Pdf`	Converte arquivo XLSX
`OfficeConverter.from_xlsx_bytes(data)`	`Pdf`	Converte XLSX a partir de bytes
`OfficeConverter.from_pptx(path)`	`Pdf`	Converte arquivo PPTX
`OfficeConverter.from_pptx_bytes(data)`	`Pdf`	Converte PPTX a partir de bytes

Todos os métodos retornam um objeto Pdf. Chame pdf.save("output.pdf") ou pdf.to_bytes() para obter o resultado.

Rust — OfficeConverter

Método	Retorna	Descrição
`OfficeConverter::new()`	`OfficeConverter`	Cria com configuração padrão
`OfficeConverter::with_config(config)`	`OfficeConverter`	Cria com configuração personalizada
`convert(path)`	`Result<Vec<u8>>`	Detecta o formato automaticamente e converte
`convert_docx(path)`	`Result<Vec<u8>>`	Converte arquivo DOCX
`convert_docx_bytes(bytes)`	`Result<Vec<u8>>`	Converte DOCX a partir de bytes
`convert_xlsx(path)`	`Result<Vec<u8>>`	Converte arquivo XLSX
`convert_xlsx_bytes(bytes)`	`Result<Vec<u8>>`	Converte XLSX a partir de bytes
`convert_pptx(path)`	`Result<Vec<u8>>`	Converte arquivo PPTX
`convert_pptx_bytes(bytes)`	`Result<Vec<u8>>`	Converte PPTX a partir de bytes

PDF → Office — `to_docx` / `to_pptx` / `to_xlsx`

Exportado a partir de um documento PDF aberto. Disponível em Rust, Python, Go, C# e Swift.

Linguagem	Método	Retorna	Descrição
Rust	`PdfDocument::to_docx(path)`	`Result<()>`	Exporta PDF para arquivo DOCX em disco
Rust	`PdfDocument::to_docx_bytes()`	`Result<Vec<u8>>`	Exporta PDF para bytes DOCX
Rust	`PdfDocument::to_pptx(path)` / `to_pptx_bytes()`	`Result<()>` / `Result<Vec<u8>>`	Exporta PDF para PPTX
Rust	`PdfDocument::to_xlsx(path)` / `to_xlsx_bytes()`	`Result<()>` / `Result<Vec<u8>>`	Exporta PDF para XLSX
Python	`PdfDocument.to_docx(path)` / `to_docx_bytes()`	`None` / `bytes`	Exporta PDF para DOCX
Python	`PdfDocument.to_pptx(path)` / `to_pptx_bytes()`	`None` / `bytes`	Exporta PDF para PPTX
Python	`PdfDocument.to_xlsx(path)` / `to_xlsx_bytes()`	`None` / `bytes`	Exporta PDF para XLSX
Go	`(*PdfDocument).ToDocxBytes()`	`([]byte, error)`	Exporta PDF para bytes DOCX
Go	`(*PdfDocument).ToPptxBytes()`	`([]byte, error)`	Exporta PDF para bytes PPTX
Go	`(*PdfDocument).ToXlsxBytes()`	`([]byte, error)`	Exporta PDF para bytes XLSX
C#	`PdfDocument.ToDocxBytes()`	`byte[]`	Exporta PDF para bytes DOCX
C#	`PdfDocument.ToPptxBytes()`	`byte[]`	Exporta PDF para bytes PPTX
C#	`PdfDocument.ToXlsxBytes()`	`byte[]`	Exporta PDF para bytes XLSX
Swift	`Document.toDocx()`	`[UInt8]`	Exporta PDF para bytes DOCX
Swift	`Document.toPptx()`	`[UInt8]`	Exporta PDF para bytes PPTX
Swift	`Document.toXlsx()`	`[UInt8]`	Exporta PDF para bytes XLSX

Office → documento PDF — `open_from_*_bytes`

Construtores de conveniência dos bindings nativos que convertem bytes Office e devolvem um documento PDF aberto. Disponíveis em Go, C#, Swift e C ABI. Não disponíveis no PdfDocument do núcleo Rust ou em Python — use OfficeConverter nesses casos (veja a tabela acima).

Linguagem	Construtor	Retorna	Descrição
Go	`OpenFromDocxBytes(data)`	`(*PdfDocument, error)`	Abre documento PDF a partir de bytes DOCX
Go	`OpenFromPptxBytes(data)`	`(*PdfDocument, error)`	Abre documento PDF a partir de bytes PPTX
Go	`OpenFromXlsxBytes(data)`	`(*PdfDocument, error)`	Abre documento PDF a partir de bytes XLSX
C#	`PdfDocument.OpenFromDocxBytes(data)`	`PdfDocument`	Abre documento PDF a partir de bytes DOCX
C#	`PdfDocument.OpenFromPptxBytes(data)`	`PdfDocument`	Abre documento PDF a partir de bytes PPTX
C#	`PdfDocument.OpenFromXlsxBytes(data)`	`PdfDocument`	Abre documento PDF a partir de bytes XLSX
Swift	`Document.openFromDocxBytes(bytes)`	`Document`	Abre documento PDF a partir de bytes DOCX
Swift	`Document.openFromPptxBytes(bytes)`	`Document`	Abre documento PDF a partir de bytes PPTX
Swift	`Document.openFromXlsxBytes(bytes)`	`Document`	Abre documento PDF a partir de bytes XLSX
C ABI	`pdf_document_open_from_docx_bytes(data, len, error_code)`	`PdfDocument *`	Abre documento PDF a partir de bytes DOCX
C ABI	`pdf_document_open_from_pptx_bytes(data, len, error_code)`	`PdfDocument *`	Abre documento PDF a partir de bytes PPTX
C ABI	`pdf_document_open_from_xlsx_bytes(data, len, error_code)`	`PdfDocument *`	Abre documento PDF a partir de bytes XLSX

Perguntas frequentes

A conversão de PDF para DOCX preserva o layout?

Sim, dentro de certos limites. Para documentos abaixo do limite de layout (30 páginas para DOCX/PPTX, 200 para XLSX), to_docx_bytes / to_pptx_bytes / to_xlsx_bytes usam o caminho de preservação de layout, que emite cada trecho de texto PDF como um elemento posicionado e editável e incorpora as fontes do PDF original, de modo que uma ida e volta PDF → Office → PDF mantém as dimensões originais da página. Documentos maiores recorrem ao caminho de fluxo, que reorganiza o texto em parágrafos reais para que o Word/PowerPoint/Excel abra instantaneamente.

Posso converter um PDF de volta para PowerPoint ou Excel, não só para Word?

Sim. to_pptx/to_pptx_bytes mapeiam cada página PDF em um slide com o tamanho do MediaBox de origem, e to_xlsx/to_xlsx_bytes mapeiam cada página em uma planilha. Ambos estão disponíveis em Rust, Python, Go, C# e Swift.

Por que não existe `open_from_docx_bytes` no Python?

O Python expõe a direção Office → PDF através da classe de nível mais alto OfficeConverter (OfficeConverter.from_docx_bytes(data) retorna um Pdf). Os construtores open_from_*_bytes são wrappers de conveniência adicionados na camada FFI nativa (Go, C#, Swift, C ABI), onde não existe uma classe conversora separada.

Preciso ter o Microsoft Office ou o LibreOffice instalado?

Não. O PDF Oxide lê e escreve o formato OOXML (DOCX/XLSX/PPTX) diretamente em Rust puro. Não há chamadas a processos externos, automação COM ou instâncias de Office sem interface gráfica — a conversão funciona da mesma forma no Linux, macOS e Windows.

Páginas relacionadas

Criar a partir do Markdown — converter texto Markdown em PDF
Criar a partir de HTML — converter HTML em PDF
Criar a partir de imagens — converter imagens em PDF
Processamento em lote — padrões de processamento paralelo

Converter PDF e documentos Office nos dois sentidos

Exemplo rápido

Formatos suportados

Documentos Word (DOCX)

A partir de bytes

Recursos DOCX suportados

Planilhas Excel (XLSX)

Recursos XLSX suportados

Apresentações PowerPoint (PPTX)

Como converter um PDF para DOCX, PPTX ou XLSX?

PDF para Word (DOCX)

PDF para PowerPoint (PPTX)

PDF para Excel (XLSX)

Como abrir um arquivo Office diretamente como documento PDF?

Configuração (Rust)

Campos de OfficeConfig

Predefinições de tamanho de página

Margens personalizadas

Conversão em lote

Referência de API

Python — OfficeConverter

Rust — OfficeConverter

PDF → Office — to_docx / to_pptx / to_xlsx

Office → documento PDF — open_from_*_bytes

Perguntas frequentes

A conversão de PDF para DOCX preserva o layout?

Posso converter um PDF de volta para PowerPoint ou Excel, não só para Word?

Por que não existe open_from_docx_bytes no Python?

Preciso ter o Microsoft Office ou o LibreOffice instalado?

Páginas relacionadas

PDF → Office — `to_docx` / `to_pptx` / `to_xlsx`

Office → documento PDF — `open_from_*_bytes`

Por que não existe `open_from_docx_bytes` no Python?