Конвертация PDF и документов Office в обоих направлениях

Конвертируйте документы Microsoft Office (Word, Excel, PowerPoint) в PDF и обратно — в DOCX, PPTX или XLSX — без установки Microsoft Office или LibreOffice. PDF Oxide напрямую разбирает формат OOXML и генерирует PDF, а также умеет преобразовывать страницы PDF обратно в редактируемые документы Office.

Поддерживаются два направления конвертации:

• Office → PDF — класс OfficeConverter (и конструкторы open_from_*_bytes) разбирают DOCX/XLSX/PPTX и создают PDF.
• PDF → Office — методы to_docx / to_pptx / to_xlsx на открытом документе экспортируют его обратно в форматы Office.

Быстрый пример

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());

R

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)

---

Поддерживаемые форматы

Формат	Расширение	Описание
DOCX	.docx	Документы Word — абзацы, заголовки, списки, форматирование текста
XLSX	.xlsx, .xls	Таблицы Excel — несколько листов, автоширина столбцов, типы ячеек
PPTX	.pptx	Презентации PowerPoint — слайды, заголовки, текстовые блоки

---

Документы Word (DOCX)

Конвертируйте документы Word с сохранением заголовков, абзацев, списков и форматирования текста (полужирный, курсив, подчёркивание, цвета, размеры шрифта).

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());

R

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)

Из байт

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());

R

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)

Поддерживаемые возможности DOCX

• Абзацы с выравниванием (по левому краю, по центру, по правому краю, по ширине)
• Заголовки (стили Заголовок 1–9)
• Форматирование текста: полужирный, курсив, подчёркивание, зачёркивание
• Размеры и цвета шрифтов
• Нумерованные и маркированные списки с вложением
• Извлечение метаданных (заголовок и автор из docProps/core.xml)

---

Таблицы Excel (XLSX)

Конвертируйте таблицы в PDF с автоматическим расчётом ширины столбцов и поддержкой нескольких листов. Каждый лист отрисовывается как отдельный раздел.

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());

R

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)

Поддерживаемые возможности XLSX

• Рендеринг нескольких листов с заголовками
• Типы ячеек: строки, целые числа, числа с плавающей точкой, булевы значения, даты, ошибки
• Автоматический расчёт ширины столбцов
• Автоматические разрывы страниц при превышении доступного пространства

---

Презентации PowerPoint (PPTX)

Конвертируйте презентации в PDF. Каждый слайд становится страницей с извлечёнными заголовками и текстовыми блоками.

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());

R

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)

---

Как конвертировать PDF в DOCX, PPTX или XLSX?

Обратное направление — PDF → Office — реализовано как методы на открытом PDF-документе, а не на OfficeConverter. Откройте PDF через PdfDocument (Python/Rust), OpenFromBytes/Open (Go/C#) или Document.open (Swift), затем вызовите to_docx / to_pptx / to_xlsx для экспорта.

PDF Oxide автоматически выбирает стратегию в зависимости от числа страниц: документы в пределах порога компоновки (30 страниц для DOCX/PPTX, 200 для XLSX) используют путь с сохранением макета, где каждый текстовый фрагмент PDF помещается на позицию, близкую к исходной, как редактируемый элемент; более объёмные документы переходят на потоковый путь, перекомпоновывая содержимое так, чтобы Word/PowerPoint/Excel открывали их мгновенно. Каждая страница PDF становится разделом DOCX, слайдом PPTX или листом XLSX; исходные размеры страниц и встроенные шрифты сохраняются, поэтому при конвертации PDF → Office → PDF макет остаётся прежним.

PDF в 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)

Go

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)

C#

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());

R

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 в 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

Go

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

C#

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());

R

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 в 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

Go

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

C#

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());

R

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)

Замечание для Python: to_docx/to_pptx/to_xlsx объявлены на PdfDocument (класс для извлечения текста и инспекции), а не на OfficeConverter/Pdf (используется для направления Office → PDF). Для открытия исходного PDF применяйте PdfDocument("file.pdf").

---

Как открыть файл Office напрямую как PDF-документ?

Нативные привязки (Go, C#, Swift и C ABI) предоставляют конструкторы open_from_*_bytes, которые конвертируют байты DOCX/PPTX/XLSX и возвращают уже открытый PdfDocument — удобно, когда нужно сразу извлекать текст, рендерить или реэкспортировать без промежуточного сохранения PDF. Каждый конструктор внутри запускает OfficeConverter и открывает полученный PDF одним вызовом.

Go

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)

C#

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);

R

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 и XLSX используются соответствующие конструкторы:

Исходный формат	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: в основном PdfDocument нет конструктора open_from_docx_bytes. В Rust сначала выполните конвертацию через OfficeConverter::new().convert_docx_bytes(&data)?, затем откройте документ через PdfDocument::from_bytes(pdf_bytes)?. В Python используйте OfficeConverter.from_docx_bytes(data) (как описано выше); он возвращает 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()?);

---

Настройка (Rust)

Настройте размер страницы, поля и шрифты с помощью 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")?;

Поля OfficeConfig

Поле	Тип	Значение по умолчанию	Описание
page_size	PageSize	Letter	Размеры страницы
margins	Margins	По 1 дюйму со всех сторон	Поля страницы в пунктах (72pt = 1 дюйм)
embed_fonts	bool	false	Встраивать ли шрифты
default_font	String	"Helvetica"	Резервный шрифт
default_font_size	f32	11.0	Размер текста по умолчанию в пунктах
line_height	f32	1.2	Множитель межстрочного интервала
include_images	bool	true	Включать ли встроенные изображения

Предустановленные размеры страницы

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

Произвольные поля

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

---

Пакетная конвертация

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());
}

R

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

---

Справочник по API

<a id=“office-pdf-officeconverter”></a>

Python — OfficeConverter

Метод	Возвращает	Описание
OfficeConverter.convert(path)	Pdf	Автоопределение формата и конвертация
OfficeConverter.from_docx(path)	Pdf	Конвертация файла DOCX
OfficeConverter.from_docx_bytes(data)	Pdf	Конвертация DOCX из байт
OfficeConverter.from_xlsx(path)	Pdf	Конвертация файла XLSX
OfficeConverter.from_xlsx_bytes(data)	Pdf	Конвертация XLSX из байт
OfficeConverter.from_pptx(path)	Pdf	Конвертация файла PPTX
OfficeConverter.from_pptx_bytes(data)	Pdf	Конвертация PPTX из байт

Все методы возвращают объект Pdf. Вызовите pdf.save("output.pdf") или pdf.to_bytes() для получения результата.

Rust — OfficeConverter

Метод	Возвращает	Описание
OfficeConverter::new()	OfficeConverter	Создание с настройками по умолчанию
OfficeConverter::with_config(config)	OfficeConverter	Создание с пользовательской конфигурацией
convert(path)	Result<Vec<u8>>	Автоопределение формата и конвертация
convert_docx(path)	Result<Vec<u8>>	Конвертация файла DOCX
convert_docx_bytes(bytes)	Result<Vec<u8>>	Конвертация DOCX из байт
convert_xlsx(path)	Result<Vec<u8>>	Конвертация файла XLSX
convert_xlsx_bytes(bytes)	Result<Vec<u8>>	Конвертация XLSX из байт
convert_pptx(path)	Result<Vec<u8>>	Конвертация файла PPTX
convert_pptx_bytes(bytes)	Result<Vec<u8>>	Конвертация PPTX из байт

PDF → Office — to_docx / to_pptx / to_xlsx

Экспорт из открытого PDF-документа. Доступно в Rust, Python, Go, C# и Swift.

Язык	Метод	Возвращает	Описание
Rust	PdfDocument::to_docx(path)	Result<()>	Экспорт PDF в DOCX-файл на диске
Rust	PdfDocument::to_docx_bytes()	Result<Vec<u8>>	Экспорт PDF в байты DOCX
Rust	PdfDocument::to_pptx(path) / to_pptx_bytes()	Result<()> / Result<Vec<u8>>	Экспорт PDF в PPTX
Rust	PdfDocument::to_xlsx(path) / to_xlsx_bytes()	Result<()> / Result<Vec<u8>>	Экспорт PDF в XLSX
Python	PdfDocument.to_docx(path) / to_docx_bytes()	None / bytes	Экспорт PDF в DOCX
Python	PdfDocument.to_pptx(path) / to_pptx_bytes()	None / bytes	Экспорт PDF в PPTX
Python	PdfDocument.to_xlsx(path) / to_xlsx_bytes()	None / bytes	Экспорт PDF в XLSX
Go	(*PdfDocument).ToDocxBytes()	([]byte, error)	Экспорт PDF в байты DOCX
Go	(*PdfDocument).ToPptxBytes()	([]byte, error)	Экспорт PDF в байты PPTX
Go	(*PdfDocument).ToXlsxBytes()	([]byte, error)	Экспорт PDF в байты XLSX
C#	PdfDocument.ToDocxBytes()	byte[]	Экспорт PDF в байты DOCX
C#	PdfDocument.ToPptxBytes()	byte[]	Экспорт PDF в байты PPTX
C#	PdfDocument.ToXlsxBytes()	byte[]	Экспорт PDF в байты XLSX
Swift	Document.toDocx()	[UInt8]	Экспорт PDF в байты DOCX
Swift	Document.toPptx()	[UInt8]	Экспорт PDF в байты PPTX
Swift	Document.toXlsx()	[UInt8]	Экспорт PDF в байты XLSX

Office → PDF-документ — open_from_*_bytes

Удобные конструкторы нативных привязок, конвертирующие байты Office и возвращающие открытый PDF-документ. Доступны в Go, C#, Swift и C ABI. Недоступны в Rust-ядре PdfDocument и в Python — там используйте OfficeConverter (см. таблицу выше).

Язык	Конструктор	Возвращает	Описание
Go	OpenFromDocxBytes(data)	(*PdfDocument, error)	Открыть PDF-документ из байт DOCX
Go	OpenFromPptxBytes(data)	(*PdfDocument, error)	Открыть PDF-документ из байт PPTX
Go	OpenFromXlsxBytes(data)	(*PdfDocument, error)	Открыть PDF-документ из байт XLSX
C#	PdfDocument.OpenFromDocxBytes(data)	PdfDocument	Открыть PDF-документ из байт DOCX
C#	PdfDocument.OpenFromPptxBytes(data)	PdfDocument	Открыть PDF-документ из байт PPTX
C#	PdfDocument.OpenFromXlsxBytes(data)	PdfDocument	Открыть PDF-документ из байт XLSX
Swift	Document.openFromDocxBytes(bytes)	Document	Открыть PDF-документ из байт DOCX
Swift	Document.openFromPptxBytes(bytes)	Document	Открыть PDF-документ из байт PPTX
Swift	Document.openFromXlsxBytes(bytes)	Document	Открыть PDF-документ из байт XLSX
C ABI	pdf_document_open_from_docx_bytes(data, len, error_code)	PdfDocument *	Открыть PDF-документ из байт DOCX
C ABI	pdf_document_open_from_pptx_bytes(data, len, error_code)	PdfDocument *	Открыть PDF-документ из байт PPTX
C ABI	pdf_document_open_from_xlsx_bytes(data, len, error_code)	PdfDocument *	Открыть PDF-документ из байт XLSX

---

Часто задаваемые вопросы

Сохраняется ли макет при конвертации PDF в DOCX?

Да, в пределах возможностей. Для документов в пределах порога компоновки (30 страниц для DOCX/PPTX, 200 для XLSX) to_docx_bytes / to_pptx_bytes / to_xlsx_bytes используют путь с сохранением макета: каждый текстовый фрагмент PDF размещается как позиционированный редактируемый элемент, а шрифты исходного PDF встраиваются, поэтому при конвертации PDF → Office → PDF исходные размеры страниц сохраняются. Более объёмные документы переходят на потоковый путь, перекомпоновывая текст в настоящие абзацы, чтобы Word/PowerPoint/Excel открывали их мгновенно.

Можно ли конвертировать PDF не только в Word, но и в PowerPoint или Excel?

Да. to_pptx/to_pptx_bytes отображают каждую страницу PDF как один слайд с размерами, совпадающими с MediaBox источника, а to_xlsx/to_xlsx_bytes — как один лист таблицы. Оба варианта доступны в Rust, Python, Go, C# и Swift.

Почему в Python нет конструктора open_from_docx_bytes?

В Python направление Office → PDF реализовано через высокоуровневый класс OfficeConverter (OfficeConverter.from_docx_bytes(data) возвращает Pdf). Конструкторы open_from_*_bytes — это удобные обёртки, добавленные на уровне нативного FFI (Go, C#, Swift, C ABI), где нет отдельного класса-конвертера.

Нужно ли устанавливать Microsoft Office или LibreOffice?

Нет. PDF Oxide читает и записывает формат OOXML (DOCX/XLSX/PPTX) напрямую — на чистом Rust. Никаких внешних процессов, COM-автоматизации или «безголовых» экземпляров Office — конвертация одинаково работает на Linux, macOS и Windows.

---

Связанные страницы

• Создание из Markdown — конвертация Markdown-текста в PDF
• Создание из HTML — конвертация HTML в PDF
• Создание из изображений — конвертация изображений в PDF
• Пакетная обработка — паттерны параллельной обработки