PythonでPDFからテキストを抽出する

PDFテキスト抽出は、ドキュメント処理パイプラインで最も一般的なタスクの一つです。検索インデックスの構築やRAGシステムへのデータ投入から、データマイニング、コンプライアンスワークフローまで幅広く活用されています。このガイドでは、PDF Oxideを使ってPython・JavaScript・RustでPDFからテキストを抽出する方法を包括的に解説します。プレーンテキスト抽出、文字レベルの位置情報、スタイル付きスパン、スキャン文書に対するOCR、暗号化ファイルの処理、バッチパイプラインのパフォーマンスチューニングまで網羅しています。

任意のPDFから3行でテキストを抽出できます：

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("document.pdf")
text = doc.extract_text(0)  # page 0
print(text)

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

const bytes = new Uint8Array(buffer);
const doc = new WasmPdfDocument(bytes);
const text = doc.extractText(0); // page 0
console.log(text);
doc.free();

Rust

use pdf_oxide::PdfDocument;

let mut doc = PdfDocument::open("document.pdf")?;
let text = doc.extract_text(0)?;
println!("{}", text);

Go

package main

import (
    "fmt"
    "log"
    pdfoxide "github.com/yfedoseev/pdf_oxide/go"
)

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

    text, err := doc.ExtractText(0) // page 0
    if err != nil { log.Fatal(err) }
    fmt.Println(text)
}

C#

using PdfOxide;

using var doc = PdfDocument.Open("document.pdf");
var text = doc.ExtractText(0); // page 0
Console.WriteLine(text);

Java

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

try (PdfDocument doc = PdfDocument.open(Path.of("document.pdf"))) {
    String text = doc.extractText(0); // page 0
    System.out.println(text);
}

Kotlin

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

PdfDocument.open(Path.of("document.pdf")).use { doc ->
    val text = doc.extractText(0) // page 0
    println(text)
}

Scala

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

Using.resource(PdfDocument.open("document.pdf")) { doc =>
  val text = doc.extractText(0) // page 0
  println(text)
}

Clojure

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

(with-open [doc (pdf/open "document.pdf")]
  (println (pdf/extract-text doc 0))) ; page 0

PHP

use PdfOxide\PdfDocument;

$doc  = PdfDocument::open('document.pdf');
$text = $doc->extractText(0); // page 0
echo $text;
$doc->close();

Ruby

require 'pdf_oxide'

PdfOxide::PdfDocument.open('document.pdf') do |doc|
  text = doc.extract_text(0) # page 0
  puts text
end

C++

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

auto doc  = pdf_oxide::Document::open("document.pdf");
auto text = doc.extract_text(0); // page 0
std::cout << text << '\n';

Swift

import PdfOxide

let doc  = try Document.open("document.pdf")
let text = try doc.extractText(0) // page 0
print(text)

Dart

import 'package:pdf_oxide/pdf_oxide.dart';

final doc  = PdfDocument.open('document.pdf');
final text = doc.extractText(0); // page 0
print(text);
doc.close();

R

library(pdfoxide)

doc  <- pdf_open("document.pdf")
text <- pdf_extract_text(doc, 0) # page 0
cat(text)

Julia

using PdfOxide

doc  = open_document("document.pdf")
text = extract_text(doc, 0) # page 0
println(text)

Zig

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

var doc = try pdf_oxide.Document.open("document.pdf");
const text = try doc.extractText(a, 0); // page 0
std.debug.print("{s}\n", .{text});

Objective-C

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

POXDocument *doc = [POXDocument openPath:@"document.pdf" error:&err];
NSString *text = [doc extractText:0 error:&err]; // page 0
NSLog(@"%@", text);

Elixir

{:ok, doc}  = PdfOxide.open("document.pdf")
{:ok, text} = PdfOxide.extract_text(doc, 0) # page 0
IO.puts(text)

PDF Oxideはページあたり平均0.8msでテキストを抽出します。PyMuPDFより5倍、pypdfより15倍高速で、3,830件のテストPDFで100%のパス率を達成しています。

PDFテキスト抽出が難しい理由

PDFはテキスト形式ではなく、ビジュアル形式です。HTMLやMarkdownとは異なり、PDFファイルには「段落」や「文」は格納されていません。ページ上の特定の座標に配置された個々の文字が格納されています。読み取り可能なテキストを抽出するには、以下の処理が必要です：

• フォントデコード — PDFフォントはエンコードテーブル（WinAnsi、MacRoman、Unicode CMap、Type 1、TrueType、CIDFont）を使って文字コードをグリフにマッピングします。文字コード0x41があるフォントでは「A」を、別のフォントでは「α」を意味することがあります。
• テキストストリーム解析 — Tj、TJ、'、"などのテキスト演算子がページに文字を配置します。TJ配列内のカーニング調整は文字を数ポイント単位でずらします。スペースの欠落は文字位置の間隔から推定する必要があります。
• レイアウト再構築 — ページ上の文字に明示的な読み順はありません。二段組レイアウト、ヘッダー、フッター、表、サイドバーを空間的に分析して、線形のテキストフローを生成する必要があります。
• エンコードの特殊ケース — CJKテキスト（中国語、日本語、韓国語）は数千のグリフを持つCIDFont/CMAPエンコーディングを使用します。アラビア語とヘブライ語は右から左への並べ替えが必要です。合字（fi、fl、ffi）は分解する必要があります。
• 埋め込みサブセット — 多くのPDFは使用するグリフのみをカスタムエンコーディングベクターとともに埋め込みます。フォントがグリフインデックス1→「T」、2→「h」、3→「e」に標準エンコードなしでマッピングすることがあります。

これが、異なるPDFライブラリが同じファイルに対して異なるテキスト出力を生成する理由であり、複雑なドキュメントでは一部のライブラリが完全に失敗する理由です。PDF OxideはRustベースのパーサーでこれらすべてのケースを処理し、3,830件の実際のPDFで100%のパス率を達成しています。

インストール

Python（PyPI）：

pip install pdf_oxide

Linux（x86_64、aarch64）、macOS（IntelおよびApple Silicon）、Windows（x86_64）向けのビルド済みホイールが提供されています。Python 3.8以上。システム依存関係なし — RustコアはWheelにコンパイルされているため、Poppler、MuPDF、またはCライブラリをインストールする必要はありません。

JavaScript（npm）：

npm install pdf-oxide-wasm

Node.js 18以上と最新ブラウザで動作します。WASMバイナリはパッケージにバンドルされています。

Rust（Cargo）：

cargo add pdf_oxide

Rust 1.70以上が必要です。標準的なRustツールチェーン以外のシステム依存関係はありません。

全ページのテキストを抽出する

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")
full_text = []
for i in range(doc.page_count()):
    text = doc.extract_text(i)
    full_text.append(text)

print("\n".join(full_text))

WASM

const doc = new WasmPdfDocument(bytes);
const fullText = doc.extractAllText();
console.log(fullText);
doc.free();

Rust

let mut doc = PdfDocument::open("report.pdf")?;
let mut full_text = Vec::new();
for i in 0..doc.page_count()? {
    full_text.push(doc.extract_text(i)?);
}
println!("{}", full_text.join("\n"));

Go

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

full, err := doc.ExtractAllText()
if err != nil { log.Fatal(err) }
fmt.Println(full)

C#

using var doc = PdfDocument.Open("report.pdf");
var parts = new List<string>();
for (int i = 0; i < doc.PageCount; i++)
    parts.Add(doc.ExtractText(i));
Console.WriteLine(string.Join("\n", parts));

Java

try (PdfDocument doc = PdfDocument.open(Path.of("report.pdf"))) {
    StringBuilder all = new StringBuilder();
    for (int i = 0; i < doc.pageCount(); i++)
        all.append(doc.extractText(i));
    System.out.println(all);
}

Kotlin

PdfDocument.open(Path.of("report.pdf")).use { doc ->
    val all = (0 until doc.pageCount()).joinToString("") { doc.extractText(it) }
    println(all)
}

Scala

Using.resource(PdfDocument.open("report.pdf")) { doc =>
  val all = (0 until doc.pageCount()).map(doc.extractText).mkString
  println(all)
}

Clojure

(with-open [doc (pdf/open "report.pdf")]
  (println (apply str (map #(pdf/extract-text doc %)
                           (range (pdf/page-count doc))))))

PHP

$doc = PdfDocument::open('report.pdf');
$all = '';
for ($i = 0; $i < $doc->pageCount(); $i++) { $all .= $doc->extractText($i); }
echo $all;
$doc->close();

Ruby

PdfOxide::PdfDocument.open('report.pdf') do |doc|
  all = (0...doc.page_count).map { |i| doc.extract_text(i) }.join
  puts all
end

C++

auto doc = pdf_oxide::Document::open("report.pdf");
auto all = doc.extract_all_text();
std::cout << all << '\n';

Swift

let doc = try Document.open("report.pdf")
let all = try doc.extractAllText()
print(all)

Dart

final doc = PdfDocument.open('report.pdf');
final all = doc.extractAllText();
print(all);
doc.close();

R

doc <- pdf_open("report.pdf")
all <- pdf_extract_all_text(doc)
cat(all)

Julia

doc = open_document("report.pdf")
all = extract_all_text(doc)
println(all)

Zig

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

Objective-C

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

Elixir

{:ok, doc} = PdfOxide.open("report.pdf")
{:ok, n}   = PdfOxide.page_count(doc)
all = 0..(n - 1)
      |> Enum.map(fn i -> {:ok, t} = PdfOxide.extract_text(doc, i); t end)
      |> Enum.join()
IO.puts(all)

文字位置情報付きのテキスト抽出

すべての文字の正確な座標、フォント名、サイズを取得します：

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("paper.pdf")
chars = doc.extract_chars(0)

for ch in chars[:20]:
    print(f"'{ch.char}' at ({ch.x:.1f}, {ch.y:.1f}) "
          f"font={ch.font_name} size={ch.font_size:.1f}")

WASM

const doc = new WasmPdfDocument(bytes);
const chars = doc.extractChars(0);
for (const ch of chars.slice(0, 20)) {
    console.log(`'${ch.char}' at (${ch.x.toFixed(1)}, ${ch.y.toFixed(1)}) font=${ch.fontName} size=${ch.fontSize.toFixed(1)}`);
}
doc.free();

Rust

let mut doc = PdfDocument::open("paper.pdf")?;
let chars = doc.extract_chars(0)?;
for ch in chars.iter().take(20) {
    println!("'{}' at ({:.1}, {:.1}) font={} size={:.1}",
        ch.char, ch.x, ch.y, ch.font_name, ch.font_size);
}

Go

doc, _ := pdfoxide.Open("paper.pdf")
defer doc.Close()

chars, _ := doc.ExtractChars(0)
for _, ch := range chars[:20] {
    fmt.Printf("%q at (%.1f, %.1f) font=%s size=%.1f\n",
        ch.Char, ch.X, ch.Y, ch.FontName, ch.FontSize)
}

C#

using var doc = PdfDocument.Open("paper.pdf");
var chars = doc.ExtractChars(0);
foreach (var ch in chars.Take(20))
    Console.WriteLine($"'{ch.Char}' at ({ch.X:F1}, {ch.Y:F1}) font={ch.FontName} size={ch.FontSize:F1}");

Java

import fyi.oxide.pdf.text.TextChar;

try (PdfDocument doc = PdfDocument.open(Path.of("paper.pdf"))) {
    for (TextChar ch : doc.page(0).chars().subList(0, 20)) {
        System.out.printf("'%s' at (%.1f, %.1f)%n",
            ch.asString(), ch.bbox().x0(), ch.bbox().y0());
    }
}

Kotlin

PdfDocument.open(Path.of("paper.pdf")).use { doc ->
    doc.page(0).chars().take(20).forEach { ch ->
        println("'${ch.asString()}' at (${ch.bbox().x0()}, ${ch.bbox().y0()})")
    }
}

Scala

import fyi.oxide.pdf.charsSeq

Using.resource(PdfDocument.open("paper.pdf")) { doc =>
  doc.page(0).charsSeq.take(20).foreach { ch =>
    println(f"'${ch.asString}' at (${ch.bbox.x0}%.1f, ${ch.bbox.y0}%.1f)")
  }
}

Clojure

(with-open [doc (pdf/open "paper.pdf")]
  (doseq [ch (take 20 (pdf/chars (pdf/page doc 0)))]
    (let [b (.bbox ch)]
      (println (format "'%s' at (%.1f, %.1f)"
                       (.asString ch) (.x0 b) (.y0 b))))))

C++

auto doc   = pdf_oxide::Document::open("paper.pdf");
auto chars = doc.extract_chars(0);
int shown = 0;
for (const auto& ch : chars) {
    if (shown++ >= 20) break;
    std::printf("U+%04X at (%.1f, %.1f) font=%s size=%.1f\n",
        ch.character, ch.bbox.x, ch.bbox.y,
        ch.font_name.c_str(), ch.font_size);
}

Swift

let doc   = try Document.open("paper.pdf")
let chars = try doc.extractChars(0)
for ch in chars.prefix(20) {
    let s = String(UnicodeScalar(ch.character) ?? " ")
    print("'\(s)' at (\(ch.bbox.x), \(ch.bbox.y)) font=\(ch.fontName) size=\(ch.fontSize)")
}

Dart

final doc   = PdfDocument.open('paper.pdf');
final chars = doc.extractChars(0);
for (final ch in chars.take(20)) {
  final s = String.fromCharCode(ch.character);
  print("'$s' at (${ch.bbox.x}, ${ch.bbox.y}) "
      "font=${ch.fontName} size=${ch.fontSize}");
}
doc.close();

R

doc   <- pdf_open("paper.pdf")
chars <- pdf_extract_chars(doc, 0)
for (ch in head(chars, 20)) {
  cat(sprintf("'%s' at (%.1f, %.1f) font=%s size=%.1f\n",
              intToUtf8(ch$character), ch$bbox$x, ch$bbox$y,
              ch$font_name, ch$font_size))
}

Julia

doc   = open_document("paper.pdf")
chars = extract_chars(doc, 0)
for ch in chars[1:min(20, end)]
    println("'$(Char(ch.character))' at ($(ch.bbox.x), $(ch.bbox.y)) ",
            "font=$(ch.font_name) size=$(ch.font_size)")
end

Zig

var doc = try pdf_oxide.Document.open("paper.pdf");
const chars = try doc.extractChars(a, 0);
defer pdf_oxide.Document.freeChars(a, chars);
for (chars[0..@min(20, chars.len)]) |ch| {
    std.debug.print("U+{X:0>4} at ({d:.1}, {d:.1}) font={s} size={d:.1}\n",
        .{ ch.character, ch.bbox.x, ch.bbox.y, ch.fontName, ch.fontSize });
}

Objective-C

POXDocument *doc = [POXDocument openPath:@"paper.pdf" error:&err];
NSArray<POXChar*> *chars = [doc extractChars:0 error:&err];
for (POXChar *ch in [chars subarrayWithRange:NSMakeRange(0, MIN(20, chars.count))]) {
    NSLog(@"U+%04X at (%.1f, %.1f) font=%@ size=%.1f",
        ch.character, ch.bbox.x, ch.bbox.y, ch.fontName, ch.fontSize);
}

Elixir

{:ok, doc}   = PdfOxide.open("paper.pdf")
{:ok, chars} = PdfOxide.extract_chars(doc, 0)
chars
|> Enum.take(20)
|> Enum.each(fn ch ->
  IO.puts("'#{<<ch.character::utf8>>}' at (#{ch.bbox.x}, #{ch.bbox.y}) " <>
          "font=#{ch.font_name} size=#{ch.font_size}")
end)

各文字には以下の情報が含まれます：

フィールド	型	説明
char	str	Unicode文字
x, y	float	ポイント単位の位置
font_size	float	ポイント単位のフォントサイズ
font_name	str	PostScriptフォント名
bbox	tuple	バウンディングボックス (x0, y0, x1, y1)

文字レベルの抽出は、表の再構築、フォントサイズによる見出し検出、またはテキスト領域のバウンディングボックス作成に役立ちます。たとえば、y座標で文字を行にグループ化し、x位置のギャップから列の境界を検出できます。

スタイル付きテキストスパンの抽出

フォントとサイズで連続する文字をグループ化します：

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("paper.pdf")
spans = doc.extract_spans(0)

for span in spans:
    print(f"'{span.text}' font={span.font_name} size={span.font_size:.1f}")

WASM

const doc = new WasmPdfDocument(bytes);
const spans = doc.extractSpans(0);
for (const span of spans) {
    console.log(`'${span.text}' font=${span.fontName} size=${span.fontSize.toFixed(1)}`);
}
doc.free();

Rust

let mut doc = PdfDocument::open("paper.pdf")?;
let spans = doc.extract_spans(0)?;
for span in &spans {
    println!("'{}' font={} size={:.1}", span.text, span.font_name, span.font_size);
}

見出し、太字テキストの検出、または構造化出力の生成に役立ちます。

バッチ処理

数百から数千のPDFを一括処理します：

from pdf_oxide import PdfDocument, PdfError
from pathlib import Path

pdf_dir = Path("documents/")
for pdf_path in pdf_dir.glob("*.pdf"):
    try:
        doc = PdfDocument(str(pdf_path))
        for i in range(doc.page_count()):
            text = doc.extract_text(i)
            # Process text...
    except PdfError as e:
        print(f"Skipped {pdf_path.name}: {e}")

ページあたり0.8msで、3,830件のPDF処理にかかる時間はわずか約3.1秒です。本番パイプラインでは、multiprocessingとasync I/Oを使った並列処理パターンについてバッチ処理ガイドを参照してください。

スキャンPDFの処理（OCR）

PDFにテキストではなくスキャン画像が含まれている場合、extract_text()は空または最小限の出力を返します。PDF Oxideの組み込みOCRを使用してください：

from pdf_oxide import PdfDocument

doc = PdfDocument("scanned.pdf")
text = doc.extract_text(0)

if not text.strip():
    # Page is likely scanned — use OCR
    text = doc.extract_text_ocr(0)
    print(text)

PDF OxideはONNX Runtime経由でPaddleOCRを使用しています。Tesseractのインストールは不要です。モデルの選択と設定についてはOCRガイドを参照してください。

暗号化PDFの処理

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("protected.pdf", password="secret")
text = doc.extract_text(0)
print(text)

WASM

const doc = new WasmPdfDocument(bytes);
doc.authenticate("secret");
const text = doc.extractText(0);
console.log(text);
doc.free();

Rust

let mut doc = PdfDocument::open_with_password("protected.pdf", "secret")?;
let text = doc.extract_text(0)?;
println!("{}", text);

Go

doc, _ := pdfoxide.Open("protected.pdf")
defer doc.Close()

if _, err := doc.Authenticate("secret"); err != nil { log.Fatal(err) }
text, _ := doc.ExtractText(0)
fmt.Println(text)

C#

using var doc = PdfDocument.OpenWithPassword("protected.pdf", "secret");
Console.WriteLine(doc.ExtractText(0));

Java

try (PdfDocument doc = PdfDocument.open("protected.pdf", "secret")) {
    System.out.println(doc.extractText(0));
}

Kotlin

PdfDocument.open("protected.pdf", "secret").use { doc ->
    println(doc.extractText(0))
}

Scala

Using.resource(PdfDocument.open("protected.pdf", "secret")) { doc =>
  println(doc.extractText(0))
}

Clojure

(with-open [doc (pdf/open "protected.pdf" "secret")]
  (println (pdf/extract-text doc 0)))

Ruby

PdfOxide::PdfDocument.open('protected.pdf', password: 'secret') do |doc|
  puts doc.extract_text(0)
end

C++

auto doc = pdf_oxide::Document::open_with_password("protected.pdf", "secret");
std::cout << doc.extract_text(0) << '\n';

Swift

let doc = try Document.openWithPassword("protected.pdf", password: "secret")
print(try doc.extractText(0))

Dart

final doc = PdfDocument.openWithPassword('protected.pdf', 'secret');
print(doc.extractText(0));
doc.close();

R

doc <- pdf_open_with_password("protected.pdf", "secret")
cat(pdf_extract_text(doc, 0))

Julia

doc = open_with_password("protected.pdf", "secret")
println(extract_text(doc, 0))

Zig

var doc = try pdf_oxide.Document.openWithPassword("protected.pdf", "secret");
const text = try doc.extractText(a, 0);
std.debug.print("{s}\n", .{text});

Objective-C

POXDocument *doc = [POXDocument openWithPassword:@"protected.pdf"
                                       password:@"secret" error:&err];
NSLog(@"%@", [doc extractText:0 error:&err]);

Elixir

{:ok, doc}  = PdfOxide.open_with_password("protected.pdf", "secret")
{:ok, text} = PdfOxide.extract_text(doc, 0)
IO.puts(text)

AES-256、AES-128、RC4で暗号化されたPDFに対応しています。暗号化ファイルをまったく開けないpdfplumberや、AES-256で失敗するpdfminerとは異なり、PDF Oxideはすべての標準的なPDF暗号化方式を透過的に処理します。

Markdownとして出力する

見出しと書式を保持した構造化出力を得るには：

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("paper.pdf")
md = doc.to_markdown(0, detect_headings=True)
print(md)

WASM

const doc = new WasmPdfDocument(bytes);
const md = doc.toMarkdown(0);
console.log(md);
doc.free();

Rust

let mut doc = PdfDocument::open("paper.pdf")?;
let md = doc.to_markdown(0, true)?;
println!("{}", md);

Go

doc, _ := pdfoxide.Open("paper.pdf")
defer doc.Close()

md, _ := doc.ToMarkdown(0)
fmt.Println(md)

C#

using var doc = PdfDocument.Open("paper.pdf");
Console.WriteLine(doc.ToMarkdown(0));

Java

try (PdfDocument doc = PdfDocument.open(Path.of("paper.pdf"))) {
    System.out.println(doc.toMarkdown(0));
}

Kotlin

PdfDocument.open(Path.of("paper.pdf")).use { doc ->
    println(doc.toMarkdown(0))
}

Scala

Using.resource(PdfDocument.open("paper.pdf")) { doc =>
  println(doc.toMarkdown(0))
}

Clojure

(with-open [doc (pdf/open "paper.pdf")]
  (println (pdf/to-markdown doc 0)))

PHP

$doc = PdfDocument::open('paper.pdf');
echo $doc->toMarkdown(0);
$doc->close();

Ruby

PdfOxide::PdfDocument.open('paper.pdf') do |doc|
  puts doc.to_markdown(0)
end

C++

auto doc = pdf_oxide::Document::open("paper.pdf");
std::cout << doc.to_markdown(0) << '\n';

Swift

let doc = try Document.open("paper.pdf")
print(try doc.toMarkdown(0))

Dart

final doc = PdfDocument.open('paper.pdf');
print(doc.toMarkdown(0));
doc.close();

R

doc <- pdf_open("paper.pdf")
cat(pdf_to_markdown(doc, 0))

Julia

doc = open_document("paper.pdf")
println(to_markdown(doc, 0))

Zig

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

Objective-C

POXDocument *doc = [POXDocument openPath:@"paper.pdf" error:&err];
NSLog(@"%@", [doc toMarkdown:0 error:&err]);

Elixir

{:ok, doc} = PdfOxide.open("paper.pdf")
{:ok, md}  = PdfOxide.to_markdown(doc, 0)
IO.puts(md)

RAGとLLM統合パターンについてはPDFからMarkdownへのガイドを参照してください。

PDF内のテキスト検索

位置データとともに全ページにわたってテキストを検索します：

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("manual.pdf")
results = doc.search("configuration")
for r in results:
    print(f"Page {r.page}: '{r.text}' at ({r.x:.0f}, {r.y:.0f})")

WASM

const doc = new WasmPdfDocument(bytes);
const results = doc.search("configuration", false);
for (const r of results) {
    console.log(`Page ${r.page}: '${r.text}' at (${r.x.toFixed(0)}, ${r.y.toFixed(0)})`);
}
doc.free();

Rust

let mut pdf = Pdf::open("manual.pdf")?;
let results = pdf.search("configuration")?;
for r in &results {
    println!("Page {}: '{}' at ({:.0}, {:.0})", r.page, r.text, r.bbox.x, r.bbox.y);
}

Go

doc, _ := pdfoxide.Open("manual.pdf")
defer doc.Close()

results, _ := doc.SearchAll("configuration", false)
for _, r := range results {
    fmt.Printf("Page %d: %q at (%.0f, %.0f)\n", r.PageIndex, r.Text, r.X, r.Y)
}

C#

using var doc = PdfDocument.Open("manual.pdf");
foreach (var r in doc.SearchAll("configuration", caseSensitive: false))
    Console.WriteLine($"Page {r.PageIndex}: '{r.Text}' at ({r.X:F0}, {r.Y:F0})");

Java

import fyi.oxide.pdf.search.SearchMatch;

try (PdfDocument doc = PdfDocument.open(Path.of("manual.pdf"))) {
    for (SearchMatch m : doc.search("configuration")) {
        System.out.printf("Page %d: '%s' at (%.0f, %.0f)%n",
            m.pageIndex(), m.text(), m.bbox().x0(), m.bbox().y0());
    }
}

Kotlin

PdfDocument.open(Path.of("manual.pdf")).use { doc ->
    for (m in doc.search("configuration")) {
        println("Page ${m.pageIndex()}: '${m.text()}' at (${m.bbox().x0()}, ${m.bbox().y0()})")
    }
}

Scala

import fyi.oxide.pdf.searchSeq

Using.resource(PdfDocument.open("manual.pdf")) { doc =>
  for (m <- doc.searchSeq("configuration"))
    println(f"Page ${m.pageIndex}: '${m.text}' at (${m.bbox.x0}%.0f, ${m.bbox.y0}%.0f)")
}

Clojure

(with-open [doc (pdf/open "manual.pdf")]
  (doseq [m (pdf/search doc "configuration")]
    (let [b (.bbox m)]
      (println (format "Page %d: '%s' at (%.0f, %.0f)"
                       (.pageIndex m) (.text m) (.x0 b) (.y0 b))))))

Ruby

PdfOxide::PdfDocument.open('manual.pdf') do |doc|
  doc.search('configuration').each do |r|
    puts "Page #{r[:page]}: '#{r[:text]}' at (#{r[:bbox][:x].round}, #{r[:bbox][:y].round})"
  end
end

C++

auto doc = pdf_oxide::Document::open("manual.pdf");
for (const auto& r : doc.search_all("configuration", /*case_sensitive=*/false)) {
    std::printf("Page %d: '%s' at (%.0f, %.0f)\n",
        r.page, r.text.c_str(), r.bbox.x, r.bbox.y);
}

Swift

let doc = try Document.open("manual.pdf")
for r in try doc.searchAll("configuration", false) {
    print("Page \(r.page): '\(r.text)' at (\(r.bbox.x), \(r.bbox.y))")
}

Dart

final doc = PdfDocument.open('manual.pdf');
for (final r in doc.searchAll('configuration', false)) {
  print("Page ${r.page}: '${r.text}' at (${r.bbox.x}, ${r.bbox.y})");
}
doc.close();

R

doc <- pdf_open("manual.pdf")
for (r in pdf_search_all(doc, "configuration", case_sensitive = FALSE)) {
  cat(sprintf("Page %d: '%s' at (%.0f, %.0f)\n",
              r$page, r$text, r$bbox$x, r$bbox$y))
}

Julia

doc = open_document("manual.pdf")
for r in search_all(doc, "configuration", false)
    println("Page $(r.page): '$(r.text)' at ($(r.bbox.x), $(r.bbox.y))")
end

Zig

var doc = try pdf_oxide.Document.open("manual.pdf");
const hits = try doc.searchAll(a, "configuration", false);
defer pdf_oxide.Document.freeSearchResults(a, hits);
for (hits) |r| {
    std.debug.print("Page {d}: '{s}' at ({d:.0}, {d:.0})\n",
        .{ r.page, r.text, r.bbox.x, r.bbox.y });
}

Objective-C

POXDocument *doc = [POXDocument openPath:@"manual.pdf" error:&err];
for (POXSearchResult *r in [doc searchAll:@"configuration" caseSensitive:NO error:&err]) {
    NSLog(@"Page %ld: '%@' at (%.0f, %.0f)",
        (long)r.page, r.text, r.bbox.x, r.bbox.y);
}

Elixir

{:ok, doc}  = PdfOxide.open("manual.pdf")
{:ok, hits} = PdfOxide.search_all(doc, "configuration", false)
Enum.each(hits, fn r ->
  IO.puts("Page #{r.page}: '#{r.text}' at (#{r.bbox.x}, #{r.bbox.y})")
end)

他のPython PDFライブラリとの比較

PDFテキスト抽出のためのPythonライブラリはいくつかあります。それぞれの特徴を比較します：

• pypdf — 純粋なPython製でC依存関係なし。インストールは簡単ですが低速（ページあたり12ms）で、フォントとエンコーディングのサポートが限定的なため1.6%のPDFで失敗します。文字位置データなし。速度が問題にならないシンプルなPDFに適しています。
• pdfplumber — pdfminer上に構築され、詳細な文字と表の抽出が可能。非常に低速（ページあたり23ms）で暗号化PDFを開けません。セルレベルのデータが必要でパフォーマンスが不要な表抽出に最適です。
• PyMuPDF (fitz) — MuPDF Cライブラリへのバインディング。高速（ページあたり4.6ms）で信頼性が高い（パス率99.3%）。Cライブラリのインストールが必要でAGPLライセンス。ライセンスが問題なければ堅実な選択です。
• pypdfium2 — GoogleのPDFiumエンジンへのバインディング。高速（ページあたり4.1ms）ですが複雑なドキュメントでのp99レイテンシが高い（42ms）。PyMuPDFと比べてAPIが限定的です。
• pdfminer.six — 詳細なレイアウト分析を持つ純粋なPython製。非常に低速でメンテナンスされていません。AES-256暗号化PDFで失敗します。pdfplumberにほぼ置き換えられています。
• PDF Oxide — PyO3経由のPythonバインディングを持つRust製。最速（ページあたり0.8ms）、100%パス率、すべての暗号化方式に対応、組み込みOCR搭載。システム依存関係なしのMITライセンス。

PDF Oxideは既存のライブラリのギャップを埋めるために構築されました：純粋なPythonパーサーの速度制限、MuPDFのライセンス制約、そして異常なフォント・壊れたクロスリファレンステーブル・非標準エンコーディングを持つ実際のPDFでライブラリが失敗する信頼性の問題を解決します。

パフォーマンス：PDF Oxideはどれくらい速い？

3つの独立した公開テストスイートから集めた3,830件のPDFでベンチマークを実施：

ライブラリ	平均	p99	パス率
PDF Oxide	0.8ms	9ms	100%
PyMuPDF	4.6ms	28ms	99.3%
pypdfium2	4.1ms	42ms	99.2%
pypdf	12.1ms	97ms	98.4%
pdfplumber	23.2ms	189ms	98.8%

10,000件のPDFを処理するパイプラインの場合：

• PDF Oxide: 8秒
• PyMuPDF: 46秒
• pypdf: 2分
• pdfplumber: 3.9分

方法論と再現手順については完全なベンチマークを参照してください。

よくある問題とトラブルシューティング

テキスト出力が空の場合

extract_text()が空文字列を返す場合、そのページにはテキストではなくスキャン画像が含まれている可能性が高いです。代わりにextract_text_ocr()を使用してください。セットアップ手順についてはスキャンPDFのOCRを参照してください。

文字化けまたは不正な文字

これは通常、非標準のエンコーディングベクターを持つフォント、またはToUnicode CMapが欠如していることを示します。PDF Oxideはほとんどのエンコーディング特殊ケースを処理しますが、一部の意図的に難読化されたPDF（DRM保護コンテンツ）では誤った出力が生成される場合があります。

スペースの欠落または単語の結合

PDFテキスト演算子は文字を個別に配置します。スペースの推定はフォントのスペース幅に対する文字位置間のギャップに依存します。単語が結合して表示される場合は、extract_chars()を使用して文字位置に基づくカスタムスペーシングロジックを適用してください。

他のライブラリと異なる出力

異なるライブラリはスペース推定、改行、読み順に異なるヒューリスティクスを使用します。PDF OxideはPyMuPDFと3,830件のPDFで99.5%のテキスト一致を達成しています。0.5%の違いは空白の正規化と合字の処理にあります。

実際の活用事例

検索インデックス作成 — ドキュメントリポジトリ内のすべてのPDFの全ページからテキストを抽出し、Elasticsearch、Typesense、またはベクターデータベースに投入して全文検索を実現します。PDF Oxideの速度により、数千のドキュメントをオンデマンドで再インデックス化することが現実的になります。

RAGパイプライン（検索拡張生成） — PDFテキストを抽出してチャンク化し、OpenAI、Cohere、またはオープンソースモデルで埋め込みを生成します。extract_spans()を使用して見出し構造を保持することで、チャンクがドキュメントのセクションと一致するようにします。LLMに最適化された出力についてはPDFからMarkdownへのガイドを参照してください。

コンプライアンスと監査 — 契約書、請求書、規制申請書を特定の条項やキーワードでスキャンします。doc.search()を使用して正確な位置とともに全ページにわたって用語を検索したり、NLPベースの条項検出のために全文を抽出したりします。

データ抽出 — 請求書、レシート、銀行明細書、フォームから構造化データを取り出します。位置データのためのextract_chars()とドメイン固有のルールを組み合わせて、「合計金額」や「請求日」などのフィールドを特定し、隣接する値を抽出します。

学術研究 — 文献レビュー、引用抽出、メタ分析のために何千もの研究論文を処理します。PDF OxideはLaTeX、Word、InDesign、Quarkなどの全範囲のPDF生成ソフトウェアと学術出版物に見られるフォントエンコーディングに対応しています。

関連ページ

• テキスト抽出API — 完全なAPIリファレンス
• PDFからMarkdownへ — 構造化変換
• バッチ処理 — 並列処理パターン
• スキャンPDFのOCR — OCRのセットアップと使用方法
• パフォーマンスベンチマーク — ベンチマークの方法論と結果