PDFとOfficeドキュメントの相互変換

Microsoft Office文書（Word、Excel、PowerPoint）をPDFに変換、またはPDFをDOCX・PPTX・XLSXに戻す変換を、Microsoft OfficeもLibreOfficeも不要で実行できます。PDF OxideはOOXML形式を直接解析してPDFを生成し、PDFページを編集可能なOfficeドキュメントにレンダリングします。

変換の方向は2通りです。

• 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文書をPDFに変換します。

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に変換します。各スライドはタイトルとテキストボックスが抽出された1ページになります。

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）は、OfficeConverter ではなく開いているPDFドキュメント上のメソッドです。PdfDocument（Python/Rust）、OpenFromBytes/Open（Go/C#）、または Document.open（Swift）でPDFを開き、to_docx / to_pptx / to_xlsx を呼び出してOffice形式にエクスポートします。

PDF Oxideはページ数に基づいて変換方式を自動選択します。レイアウト閾値（DOCX/PPTXは30ページ、XLSXは200ページ）以下のドキュメントは、各テキストスパンをソース位置に近い位置に配置するレイアウト保持方式を使用します。それより大きいドキュメントは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 はOffice → PDF方向で使う OfficeConverter/Pdf ビルダーではなく、PdfDocument（テキスト抽出・検査クラス）上で公開されています。ソースPDFを開くには PdfDocument("file.pdf") を使用してください。

---

OfficeファイルをPDFドキュメントとして直接開くには？

ネイティブバインディング（Go、C#、Swift、C ABI）は、DOCX/PPTX/XLSXのバイト列を変換して既に開いた PdfDocument を返す open_from_*_bytes コンストラクタを提供しています。中間のPDFを保存せず、すぐにテキスト抽出・レンダリング・再エクスポートを行いたい場合に便利です。各コンストラクタは内部で OfficeConverter を実行し、結果のPDFを1回の呼び出しで開きます。

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)	DOCXバイト列からPDFドキュメントを開く
Go	OpenFromPptxBytes(data)	(*PdfDocument, error)	PPTXバイト列からPDFドキュメントを開く
Go	OpenFromXlsxBytes(data)	(*PdfDocument, error)	XLSXバイト列からPDFドキュメントを開く
C#	PdfDocument.OpenFromDocxBytes(data)	PdfDocument	DOCXバイト列からPDFドキュメントを開く
C#	PdfDocument.OpenFromPptxBytes(data)	PdfDocument	PPTXバイト列からPDFドキュメントを開く
C#	PdfDocument.OpenFromXlsxBytes(data)	PdfDocument	XLSXバイト列からPDFドキュメントを開く
Swift	Document.openFromDocxBytes(bytes)	Document	DOCXバイト列からPDFドキュメントを開く
Swift	Document.openFromPptxBytes(bytes)	Document	PPTXバイト列からPDFドキュメントを開く
Swift	Document.openFromXlsxBytes(bytes)	Document	XLSXバイト列からPDFドキュメントを開く
C ABI	pdf_document_open_from_docx_bytes(data, len, error_code)	PdfDocument *	DOCXバイト列からPDFドキュメントを開く
C ABI	pdf_document_open_from_pptx_bytes(data, len, error_code)	PdfDocument *	PPTXバイト列からPDFドキュメントを開く
C ABI	pdf_document_open_from_xlsx_bytes(data, len, error_code)	PdfDocument *	XLSXバイト列からPDFドキュメントを開く

---

よくある質問

PDFをDOCXに変換するとレイアウトは保持されますか？

はい、ある程度は保持されます。レイアウト閾値（DOCX/PPTXは30ページ、XLSXは200ページ）以下のドキュメントでは、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サイズに合わせた1枚のスライドにマッピングし、to_xlsx/to_xlsx_bytes は各ページを1枚のワークシートにマッピングします。どちらもRust、Python、Go、C#、Swiftで使用できます。

PythonにはなぜDOCXバイト列を開くコンストラクタがないのですか？

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に変換
• バッチ処理 — 並列処理パターン