Quick Start

Use Xberg’s core API through extract, extract_batch, ExtractInput, and the ExtractionResult envelope. Install your binding first: Installation.

TypeScript users: @xberg-io/xberg for Node.js, @xberg-io/xberg-wasm for browsers and edge runtimes — see Language Support.

Your First Extraction

Pass an ExtractInput with kind = "uri" to extract a local path, file:// URI, or HTTP(S) URL. extract returns an ExtractionResult with a results list:

Tests URI extraction API

import asyncio
from xberg import extract, ExtractInput, ExtractInputKind

async def main() -> None:
    input = ExtractInput(kind=ExtractInputKind("uri"), uri="https://example.com/pdf/fake_memo.pdf")
    result = await extract(input)
    print(result.results[0].content)

asyncio.run(main())

Tests URI extraction API

import { ExtractInput, ExtractInputKind, extract } from "@xberg-io/xberg";
async function main() {
  const input: ExtractInput = { kind: ExtractInputKind.Uri, uri: "https://example.com/pdf/fake_memo.pdf" };
  const result = await extract(input);
  console.log(result.results?.[0]?.content);
}

void main();

Tests URI extraction API

import { WasmExtractInput, WasmExtractInputKind, extract } from "@xberg-io/xberg-wasm";
async function main() {
  const input: WasmExtractInput = (() => { const _u0 = WasmExtractInput.default(); _u0.kind = WasmExtractInputKind.Uri; _u0.uri = "https://example.com/pdf/fake_memo.pdf"; return _u0; })();
  const result = await extract(input, undefined);
  console.log(result.results[0].content);
}

void main();

Tests URI extraction API

use xberg::extract;
use xberg::ExtractInput;

#[tokio::main]
async fn main() {
    let input_json: serde_json::Value = serde_json::from_str(r#"{"kind":"uri","uri":"https://example.com/pdf/fake_memo.pdf"}"#).unwrap();
    let input = serde_json::from_value::<ExtractInput>(input_json).unwrap();
    let config = Default::default();
    let result = extract(input, &config).await.expect("call failed");
    println!("{:?}", result.results[0].content);
}

Tests URI extraction API

package main

import (
  "fmt"
  xberg "github.com/xberg-io/xberg/packages/go"
)

func ptr[T any](value T) *T { return &value }
func main() {
  input := xberg.ExtractInput{
    Kind: ptr(xberg.ExtractInputKindURI),
    URI:  ptr(`https://example.com/pdf/fake_memo.pdf`),
  }
  config := xberg.ExtractionConfig{}
  result, err := xberg.Extract(input, config)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result.Results[0].Content)
}

Tests URI extraction API

import io.xberg.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var inputJson = "{\"kind\":\"uri\",\"uri\":\"https://example.com/pdf/fake_memo.pdf\"}";
        var input = JsonUtil.fromJson(inputJson, ExtractInput.class);
        var result = Xberg.extract(input, ExtractionConfig.builder().build());
        System.out.println(result.results().get(0).content());
    }
}

Tests URI extraction API

import io.xberg.*
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper

fun main() = kotlinx.coroutines.runBlocking {
    val mapper = jacksonObjectMapper().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
    val input = mapper.readValue("{\"kind\":\"uri\",\"uri\":\"https://example.com/pdf/fake_memo.pdf\"}", ExtractInput::class.java)
    val configDefault = mapper.readValue("{\"url\":{\"crawl\":{\"ssrf\":{}}}}", ExtractionConfig::class.java)
    val result = Xberg.extract(input, configDefault)
    println(result.results.first().content)
}

Tests URI extraction API

using System;
using System.Text.Json;
using Xberg;

var ConfigOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var result = await XbergConverter.ExtractAsync(new ExtractInput { Kind = JsonSerializer.Deserialize<ExtractInputKind>("\"uri\"", ConfigOptions)!, Uri = "https://example.com/pdf/fake_memo.pdf" }, new ExtractionConfig());
Console.WriteLine(result.Results[0].Content);

Tests URI extraction API

import Xberg

let result = try await Xberg.extract("{\"kind\":\"uri\",\"uri\":\"https://example.com/pdf/fake_memo.pdf\"}", "{}")
debugPrint(result.results()[0].content())

Tests URI extraction API

require "xberg"
result = Xberg.extract(Xberg::ExtractInput.new(kind: 'uri', uri: 'https://example.com/pdf/fake_memo.pdf'))
puts result.results[0].content.inspect

Tests URI extraction API

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Xberg\Xberg;
use Xberg\ExtractInput;
$input = \Xberg\ExtractInput::from_json(json_encode(["kind" => "uri", "uri" => "https://example.com/pdf/fake_memo.pdf"]));
$result = Xberg::extract($input, null);
var_dump($result->getResults()[0]->content);

Tests URI extraction API

input_value = %Xberg.ExtractInput{kind: "uri", uri: "https://example.com/pdf/fake_memo.pdf"}
result = Xberg.extract_async(input_value)
IO.inspect(Enum.at(result.results, 0).content)

Tests URI extraction API

import 'dart:io';
import 'package:xberg/xberg.dart';
import 'package:xberg/src/xberg_bridge_generated/frb_generated.dart' show RustLib;
Future<void> main() async {
  await RustLib.init();
  try {
    final input = await createExtractInputFromJson(json: '{"kind":"uri","uri":"https://example.com/pdf/fake_memo.pdf"}');
    final config = await createExtractionConfigFromJson(json: '{}');
    final result = await XbergBridge.extract(input, config: config);
    stdout.writeln(result.results[0].content);
  } finally {
    RustLib.dispose();
  }
}

Tests URI extraction API

const std = @import("std");
const xberg = @import("xberg");

pub fn main() !void {
    const _result_json = try xberg.extract("{\"kind\":\"uri\",\"uri\":\"https://example.com/pdf/fake_memo.pdf\"}", "{}");
    defer std.heap.c_allocator.free(_result_json);
    std.debug.print("{s}\n", .{_result_json});

}

Tests URI extraction API

#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xberg.h"

int main(void) {
    XBERGAlefHandle input_handle = xberg_extract_input_from_json("{\"kind\":\"uri\",\"uri\":\"https://example.com/pdf/fake_memo.pdf\"}");
    XBERGAlefHandle result = xberg_extract(input_handle, 0);
    xberg_extract_input_free(input_handle);
    xberg_extraction_result_free(result);
    return EXIT_SUCCESS;
}

For the command line:

# Extract to stdout
xberg extract document.pdf

# Save to file using shell redirection
xberg extract document.pdf > output.txt

# Extract with JSON format (includes metadata)
xberg extract document.pdf --format json

Handle Errors

Handle extraction failures through your binding’s typed error surface. This example rejects an unsupported MIME type; missing files, parse failures, and OCR failures use the same language-appropriate error path: