Quality Processing

Score extracted text on a 0.0–1.0 scale, where 1.0 is highest quality. Scoring starts from 1.0 for clean prose: OCR, script, and navigation noise subtract penalties, while document structure and metadata add bonuses. The result is clamped to [0.0, 1.0]. Empty text scores 0.0; text shorter than 10 characters scores 0.1.

Factor	Max weight	Effect	Detects
OCR Artifacts	30%	Penalty	Scattered chars, repeated punctuation, malformed words
Script Content	20%	Penalty	JavaScript, CSS, HTML tags
Navigation Elements	10%	Penalty	Breadcrumbs, pagination, skip links
Document Structure	20%	Bonus	Sentence/paragraph length, punctuation distribution
Metadata Quality	10%	Bonus	Title, author, subject, description, keywords

OCR, script, and navigation penalties apply at every text length, including short fragments — there is no length threshold below which they are skipped.

Configuration

Python

Tests quality scoring produces a score value in [0.0, 1.0]

Python

import asyncio
from xberg import extract, ExtractInput, ExtractInputKind
from xberg._xberg import ExtractionConfig

async def main() -> None:
    input = ExtractInput(kind=ExtractInputKind("uri"), uri="https://example.com/pdf/fake_memo.pdf")
    config = ExtractionConfig.from_json("{\"enable_quality_processing\":true}")
    result = await extract(input, config)
    print(result.results[0].quality_score)

asyncio.run(main())

TypeScript / Node.js

Tests quality scoring produces a score value in [0.0, 1.0]

TypeScript

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

void main();

WebAssembly

Tests quality scoring produces a score value in [0.0, 1.0]

WebAssembly

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, { enableQualityProcessing: true });
  console.log(result.results[0].qualityScore);
}

void main();

Rust

Tests quality scoring produces a score value in [0.0, 1.0]

Rust

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_json: serde_json::Value = serde_json::from_str(r#"{"enable_quality_processing":true}"#).unwrap();
    let config = serde_json::from_value(config_json).unwrap();
    let result = extract(input, &config).await.expect("call failed");
    println!("{:?}", result.results[0].quality_score);
}

Go

Tests quality scoring produces a score value in [0.0, 1.0]

Go

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{
    EnableQualityProcessing: ptr(true),
  }
  result, err := xberg.Extract(input, config)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result.Results[0].QualityScore)
}

Java

Tests quality scoring produces a score value in [0.0, 1.0]

Java

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 configJson = "{\"enable_quality_processing\":true}";
        var config = JsonUtil.fromJson(configJson, ExtractionConfig.class);
        var result = Xberg.extract(input, config);
        System.out.println(result.results().get(0).qualityScore());
    }
}

Kotlin (Android)

Tests quality scoring produces a score value in [0.0, 1.0]

Kotlin (Android)

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 config = mapper.readValue("{\"enable_quality_processing\":true,\"url\":{\"crawl\":{\"ssrf\":{}}}}", ExtractionConfig::class.java)
    val result = Xberg.extract(input, config)
    println(result.results.first().qualityScore)
}

C#

Tests quality scoring produces a score value in [0.0, 1.0]

C#

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 { EnableQualityProcessing = true });
Console.WriteLine(result.Results[0].QualityScore);

Swift

Tests quality scoring produces a score value in [0.0, 1.0]

Swift

import Xberg

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

Ruby

Tests quality scoring produces a score value in [0.0, 1.0]

Ruby

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

PHP

Tests quality scoring produces a score value in [0.0, 1.0]

PHP

<?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, ["enable_quality_processing" => true]);
var_dump($result->getResults()[0]->qualityScore);

Elixir

Tests quality scoring produces a score value in [0.0, 1.0]

Elixir

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

Dart

Tests quality scoring produces a score value in [0.0, 1.0]

Dart

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: '{"enable_quality_processing":true}');
    final result = await XbergBridge.extract(input, config: config);
    stdout.writeln(result.results[0].qualityScore);
  } finally {
    RustLib.dispose();
  }
}

Zig

Tests quality scoring produces a score value in [0.0, 1.0]

Zig

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\"}", "{\"enable_quality_processing\":true}");
    defer std.heap.c_allocator.free(_result_json);
    std.debug.print("{s}\n", .{_result_json});

}

C

Tests quality scoring produces a score value in [0.0, 1.0]

C

#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 config_handle = xberg_extraction_config_from_json("{\"enable_quality_processing\":true}");
    XBERGAlefHandle result = xberg_extract(input_handle, config_handle);
    xberg_extract_input_free(input_handle);
    xberg_extraction_config_free(config_handle);
    xberg_extraction_result_free(result);
    return EXIT_SUCCESS;
}

Example

Python

Tests quality scoring produces a score value in [0.0, 1.0]

Python

import asyncio
from xberg import extract, ExtractInput, ExtractInputKind
from xberg._xberg import ExtractionConfig

async def main() -> None:
    input = ExtractInput(kind=ExtractInputKind("uri"), uri="https://example.com/pdf/fake_memo.pdf")
    config = ExtractionConfig.from_json("{\"enable_quality_processing\":true}")
    result = await extract(input, config)
    print(result.results[0].quality_score)

asyncio.run(main())

TypeScript / Node.js

Tests quality scoring produces a score value in [0.0, 1.0]

TypeScript

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

void main();

WebAssembly

Tests quality scoring produces a score value in [0.0, 1.0]

WebAssembly

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, { enableQualityProcessing: true });
  console.log(result.results[0].qualityScore);
}

void main();

Rust

Tests quality scoring produces a score value in [0.0, 1.0]

Rust

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_json: serde_json::Value = serde_json::from_str(r#"{"enable_quality_processing":true}"#).unwrap();
    let config = serde_json::from_value(config_json).unwrap();
    let result = extract(input, &config).await.expect("call failed");
    println!("{:?}", result.results[0].quality_score);
}

Go

Tests quality scoring produces a score value in [0.0, 1.0]

Go

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{
    EnableQualityProcessing: ptr(true),
  }
  result, err := xberg.Extract(input, config)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result.Results[0].QualityScore)
}

Java

Tests quality scoring produces a score value in [0.0, 1.0]

Java

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 configJson = "{\"enable_quality_processing\":true}";
        var config = JsonUtil.fromJson(configJson, ExtractionConfig.class);
        var result = Xberg.extract(input, config);
        System.out.println(result.results().get(0).qualityScore());
    }
}

Kotlin (Android)

Tests quality scoring produces a score value in [0.0, 1.0]

Kotlin (Android)

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 config = mapper.readValue("{\"enable_quality_processing\":true,\"url\":{\"crawl\":{\"ssrf\":{}}}}", ExtractionConfig::class.java)
    val result = Xberg.extract(input, config)
    println(result.results.first().qualityScore)
}

C#

Tests quality scoring produces a score value in [0.0, 1.0]

C#

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 { EnableQualityProcessing = true });
Console.WriteLine(result.Results[0].QualityScore);

Swift

Tests quality scoring produces a score value in [0.0, 1.0]

Swift

import Xberg

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

Ruby

Tests quality scoring produces a score value in [0.0, 1.0]

Ruby

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

PHP

Tests quality scoring produces a score value in [0.0, 1.0]

PHP

<?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, ["enable_quality_processing" => true]);
var_dump($result->getResults()[0]->qualityScore);

Elixir

Tests quality scoring produces a score value in [0.0, 1.0]

Elixir

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

Dart

Tests quality scoring produces a score value in [0.0, 1.0]

Dart

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: '{"enable_quality_processing":true}');
    final result = await XbergBridge.extract(input, config: config);
    stdout.writeln(result.results[0].qualityScore);
  } finally {
    RustLib.dispose();
  }
}

Zig

Tests quality scoring produces a score value in [0.0, 1.0]

Zig

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\"}", "{\"enable_quality_processing\":true}");
    defer std.heap.c_allocator.free(_result_json);
    std.debug.print("{s}\n", .{_result_json});

}

C

Tests quality scoring produces a score value in [0.0, 1.0]

C

#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 config_handle = xberg_extraction_config_from_json("{\"enable_quality_processing\":true}");
    XBERGAlefHandle result = xberg_extract(input_handle, config_handle);
    xberg_extract_input_free(input_handle);
    xberg_extraction_config_free(config_handle);
    xberg_extraction_result_free(result);
    return EXIT_SUCCESS;
}

See also

• Configuration Reference — the enable_quality_processing option
• Extraction Basics — core extraction pipeline