List Extractions - Retab Docs

from datetime import datetime
from retab import Retab

client = Retab()

# List recent extractions
extractions = client.extractions.list(
    limit=10,
    order="desc"
)

# Filter by date range
extractions = client.extractions.list(
    from_date=datetime(2024, 1, 1),
    to_date=datetime(2024, 12, 31),
    limit=50
)

# Filter by metadata
extractions = client.extractions.list(
    metadata={"source": "docs"},
)

import { Retab } from "@retab/node";

const client = new Retab({ apiKey: process.env.RETAB_API_KEY });

// List recent extractions
const recent = await client.extractions.list({
  limit: 10,
  order: "desc",
});

// Filter by date range
const byDate = await client.extractions.list({
  fromDate: new Date("2024-01-01").toISOString(),
  toDate: new Date("2024-12-31").toISOString(),
  limit: 50,
});

// Filter by metadata
const byMetadata = await client.extractions.list({
  metadata: JSON.stringify({ source: "docs" }),
});

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	retab "github.com/retab-dev/retab/clients/go"
)

func ptr[T any](v T) *T { return &v }

func main() {
	ctx := context.Background()

	client, err := retab.NewClient("")
	if err != nil {
		log.Fatal(err)
	}

	// List recent extractions
	extractions, err := client.Extractions.List(ctx, &retab.ExtractionsListParams{
		PaginationParams: retab.PaginationParams{Limit: ptr(10), Order: ptr("desc")},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)

	// Filter by date range
	from := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
	to := time.Date(2024, 12, 31, 0, 0, 0, 0, time.UTC)
	extractions, err = client.Extractions.List(ctx, &retab.ExtractionsListParams{
		PaginationParams: retab.PaginationParams{
			Limit: ptr(50),
		},
		FromDate: ptr(from.Format("2006-01-02")),
		ToDate:   ptr(to.Format("2006-01-02")),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)

	// Filter by metadata
	extractions, err = client.Extractions.List(ctx, &retab.ExtractionsListParams{
		Metadata: ptr(`{"source":"docs"}`),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)
}

require 'retab'
require 'date'

client = Retab::Client.new(api_key: ENV['RETAB_API_KEY'])

# List recent extractions
extractions = client.extractions.list(
  limit: 10,
  order: 'desc',
)

# Filter by date range
extractions = client.extractions.list(
  from_date: DateTime.new(2024, 1, 1),
  to_date: DateTime.new(2024, 12, 31),
  limit: 50,
)

# Filter by metadata
extractions = client.extractions.list(
  metadata: { 'source' => 'docs' },
)

extractions.data.each do |extraction|
  puts extraction.id
end

use retab::enums::ExtractionsOrder;
use retab::resources::extractions::ListParams;
use retab::Retab;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Retab::new(std::env::var("RETAB_API_KEY")?);

    // List recent extractions
    let _extractions = client
        .extractions()
        .list(ListParams {
            limit: Some(10),
            order: Some(ExtractionsOrder::Desc),
            ..Default::default()
        })
        .await?;

    // Filter by date range
    let _ranged = client
        .extractions()
        .list(ListParams {
            from_date: Some("2024-01-01".into()),
            to_date: Some("2024-12-31".into()),
            limit: Some(50),
            ..Default::default()
        })
        .await?;

    // Filter by metadata
    let _by_metadata = client
        .extractions()
        .list(ListParams {
            metadata: Some(r#"{"source":"docs"}"#.into()),
            ..Default::default()
        })
        .await?;
    Ok(())
}

<?php
require 'vendor/autoload.php';

use Retab\Client;

$client = new Client(apiKey: getenv('RETAB_API_KEY'));

$result = $client->extractions()->list();
print_r($result);

using Retab;
using RetabClient = Retab.Retab;

var apiKey = Environment.GetEnvironmentVariable("RETAB_API_KEY")!;
var client = new RetabClient(apiKey);

var result = await client.Extractions.ListAsync(new ExtractionsListOptions());
Console.WriteLine(result);

import com.retab.RetabClient;

public final class Example {
  public static void main(String[] args) throws Exception {
    RetabClient client = new RetabClient(System.getenv("RETAB_API_KEY"));

    var result = client.extractions().list(null, null, 10L, null, "invoice.pdf", null, null, null, null, null, null, null);
    System.out.println(result);
  }
}

curl -X 'GET' \
  'https://api.retab.com/v1/extractions?limit=10&order=desc' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer <your-api-key>'

# With filters (metadata is JSON-encoded)
curl -X 'GET' \
  'https://api.retab.com/v1/extractions?limit=50&from_date=2024-01-01T00:00:00&to_date=2024-12-31T00:00:00&metadata=%7B%22source%22%3A%22docs%22%7D' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer <your-api-key>'

{
  "data": [
    {
      "id": "extr_01G34H8J2K",
      "created_at": "2024-03-15T10:30:00Z",
      "file": {
        "id": "file_6dd6eb00688ad8d1",
        "filename": "invoice.pdf"
      },
      "output": {
        "invoice_number": "INV-2024-0042",
        "total_amount": 1234.56
      },
      "json_schema": {
        "type": "object",
        "properties": {
          "invoice_number": { "type": "string" },
          "total_amount": { "type": "number" }
        }
      },
      "metadata": {}
    }
  ],
  "list_metadata": {
    "before": null,
    "after": "extr_01G34H8J2K",
    "total_count": 150
  }
}

GET

extractions

from datetime import datetime
from retab import Retab

client = Retab()

# List recent extractions
extractions = client.extractions.list(
    limit=10,
    order="desc"
)

# Filter by date range
extractions = client.extractions.list(
    from_date=datetime(2024, 1, 1),
    to_date=datetime(2024, 12, 31),
    limit=50
)

# Filter by metadata
extractions = client.extractions.list(
    metadata={"source": "docs"},
)

import { Retab } from "@retab/node";

const client = new Retab({ apiKey: process.env.RETAB_API_KEY });

// List recent extractions
const recent = await client.extractions.list({
  limit: 10,
  order: "desc",
});

// Filter by date range
const byDate = await client.extractions.list({
  fromDate: new Date("2024-01-01").toISOString(),
  toDate: new Date("2024-12-31").toISOString(),
  limit: 50,
});

// Filter by metadata
const byMetadata = await client.extractions.list({
  metadata: JSON.stringify({ source: "docs" }),
});

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	retab "github.com/retab-dev/retab/clients/go"
)

func ptr[T any](v T) *T { return &v }

func main() {
	ctx := context.Background()

	client, err := retab.NewClient("")
	if err != nil {
		log.Fatal(err)
	}

	// List recent extractions
	extractions, err := client.Extractions.List(ctx, &retab.ExtractionsListParams{
		PaginationParams: retab.PaginationParams{Limit: ptr(10), Order: ptr("desc")},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)

	// Filter by date range
	from := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
	to := time.Date(2024, 12, 31, 0, 0, 0, 0, time.UTC)
	extractions, err = client.Extractions.List(ctx, &retab.ExtractionsListParams{
		PaginationParams: retab.PaginationParams{
			Limit: ptr(50),
		},
		FromDate: ptr(from.Format("2006-01-02")),
		ToDate:   ptr(to.Format("2006-01-02")),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)

	// Filter by metadata
	extractions, err = client.Extractions.List(ctx, &retab.ExtractionsListParams{
		Metadata: ptr(`{"source":"docs"}`),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)
}

require 'retab'
require 'date'

client = Retab::Client.new(api_key: ENV['RETAB_API_KEY'])

# List recent extractions
extractions = client.extractions.list(
  limit: 10,
  order: 'desc',
)

# Filter by date range
extractions = client.extractions.list(
  from_date: DateTime.new(2024, 1, 1),
  to_date: DateTime.new(2024, 12, 31),
  limit: 50,
)

# Filter by metadata
extractions = client.extractions.list(
  metadata: { 'source' => 'docs' },
)

extractions.data.each do |extraction|
  puts extraction.id
end

use retab::enums::ExtractionsOrder;
use retab::resources::extractions::ListParams;
use retab::Retab;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Retab::new(std::env::var("RETAB_API_KEY")?);

    // List recent extractions
    let _extractions = client
        .extractions()
        .list(ListParams {
            limit: Some(10),
            order: Some(ExtractionsOrder::Desc),
            ..Default::default()
        })
        .await?;

    // Filter by date range
    let _ranged = client
        .extractions()
        .list(ListParams {
            from_date: Some("2024-01-01".into()),
            to_date: Some("2024-12-31".into()),
            limit: Some(50),
            ..Default::default()
        })
        .await?;

    // Filter by metadata
    let _by_metadata = client
        .extractions()
        .list(ListParams {
            metadata: Some(r#"{"source":"docs"}"#.into()),
            ..Default::default()
        })
        .await?;
    Ok(())
}

<?php
require 'vendor/autoload.php';

use Retab\Client;

$client = new Client(apiKey: getenv('RETAB_API_KEY'));

$result = $client->extractions()->list();
print_r($result);

using Retab;
using RetabClient = Retab.Retab;

var apiKey = Environment.GetEnvironmentVariable("RETAB_API_KEY")!;
var client = new RetabClient(apiKey);

var result = await client.Extractions.ListAsync(new ExtractionsListOptions());
Console.WriteLine(result);

import com.retab.RetabClient;

public final class Example {
  public static void main(String[] args) throws Exception {
    RetabClient client = new RetabClient(System.getenv("RETAB_API_KEY"));

    var result = client.extractions().list(null, null, 10L, null, "invoice.pdf", null, null, null, null, null, null, null);
    System.out.println(result);
  }
}

curl -X 'GET' \
  'https://api.retab.com/v1/extractions?limit=10&order=desc' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer <your-api-key>'

# With filters (metadata is JSON-encoded)
curl -X 'GET' \
  'https://api.retab.com/v1/extractions?limit=50&from_date=2024-01-01T00:00:00&to_date=2024-12-31T00:00:00&metadata=%7B%22source%22%3A%22docs%22%7D' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer <your-api-key>'

{
  "data": [
    {
      "id": "extr_01G34H8J2K",
      "created_at": "2024-03-15T10:30:00Z",
      "file": {
        "id": "file_6dd6eb00688ad8d1",
        "filename": "invoice.pdf"
      },
      "output": {
        "invoice_number": "INV-2024-0042",
        "total_amount": 1234.56
      },
      "json_schema": {
        "type": "object",
        "properties": {
          "invoice_number": { "type": "string" },
          "total_amount": { "type": "number" }
        }
      },
      "metadata": {}
    }
  ],
  "list_metadata": {
    "before": null,
    "after": "extr_01G34H8J2K",
    "total_count": 150
  }
}

from datetime import datetime
from retab import Retab

client = Retab()

# List recent extractions
extractions = client.extractions.list(
    limit=10,
    order="desc"
)

# Filter by date range
extractions = client.extractions.list(
    from_date=datetime(2024, 1, 1),
    to_date=datetime(2024, 12, 31),
    limit=50
)

# Filter by metadata
extractions = client.extractions.list(
    metadata={"source": "docs"},
)

import { Retab } from "@retab/node";

const client = new Retab({ apiKey: process.env.RETAB_API_KEY });

// List recent extractions
const recent = await client.extractions.list({
  limit: 10,
  order: "desc",
});

// Filter by date range
const byDate = await client.extractions.list({
  fromDate: new Date("2024-01-01").toISOString(),
  toDate: new Date("2024-12-31").toISOString(),
  limit: 50,
});

// Filter by metadata
const byMetadata = await client.extractions.list({
  metadata: JSON.stringify({ source: "docs" }),
});

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	retab "github.com/retab-dev/retab/clients/go"
)

func ptr[T any](v T) *T { return &v }

func main() {
	ctx := context.Background()

	client, err := retab.NewClient("")
	if err != nil {
		log.Fatal(err)
	}

	// List recent extractions
	extractions, err := client.Extractions.List(ctx, &retab.ExtractionsListParams{
		PaginationParams: retab.PaginationParams{Limit: ptr(10), Order: ptr("desc")},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)

	// Filter by date range
	from := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
	to := time.Date(2024, 12, 31, 0, 0, 0, 0, time.UTC)
	extractions, err = client.Extractions.List(ctx, &retab.ExtractionsListParams{
		PaginationParams: retab.PaginationParams{
			Limit: ptr(50),
		},
		FromDate: ptr(from.Format("2006-01-02")),
		ToDate:   ptr(to.Format("2006-01-02")),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)

	// Filter by metadata
	extractions, err = client.Extractions.List(ctx, &retab.ExtractionsListParams{
		Metadata: ptr(`{"source":"docs"}`),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(extractions)
}

require 'retab'
require 'date'

client = Retab::Client.new(api_key: ENV['RETAB_API_KEY'])

# List recent extractions
extractions = client.extractions.list(
  limit: 10,
  order: 'desc',
)

# Filter by date range
extractions = client.extractions.list(
  from_date: DateTime.new(2024, 1, 1),
  to_date: DateTime.new(2024, 12, 31),
  limit: 50,
)

# Filter by metadata
extractions = client.extractions.list(
  metadata: { 'source' => 'docs' },
)

extractions.data.each do |extraction|
  puts extraction.id
end

use retab::enums::ExtractionsOrder;
use retab::resources::extractions::ListParams;
use retab::Retab;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Retab::new(std::env::var("RETAB_API_KEY")?);

    // List recent extractions
    let _extractions = client
        .extractions()
        .list(ListParams {
            limit: Some(10),
            order: Some(ExtractionsOrder::Desc),
            ..Default::default()
        })
        .await?;

    // Filter by date range
    let _ranged = client
        .extractions()
        .list(ListParams {
            from_date: Some("2024-01-01".into()),
            to_date: Some("2024-12-31".into()),
            limit: Some(50),
            ..Default::default()
        })
        .await?;

    // Filter by metadata
    let _by_metadata = client
        .extractions()
        .list(ListParams {
            metadata: Some(r#"{"source":"docs"}"#.into()),
            ..Default::default()
        })
        .await?;
    Ok(())
}

<?php
require 'vendor/autoload.php';

use Retab\Client;

$client = new Client(apiKey: getenv('RETAB_API_KEY'));

$result = $client->extractions()->list();
print_r($result);

using Retab;
using RetabClient = Retab.Retab;

var apiKey = Environment.GetEnvironmentVariable("RETAB_API_KEY")!;
var client = new RetabClient(apiKey);

var result = await client.Extractions.ListAsync(new ExtractionsListOptions());
Console.WriteLine(result);

import com.retab.RetabClient;

public final class Example {
  public static void main(String[] args) throws Exception {
    RetabClient client = new RetabClient(System.getenv("RETAB_API_KEY"));

    var result = client.extractions().list(null, null, 10L, null, "invoice.pdf", null, null, null, null, null, null, null);
    System.out.println(result);
  }
}

curl -X 'GET' \
  'https://api.retab.com/v1/extractions?limit=10&order=desc' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer <your-api-key>'

# With filters (metadata is JSON-encoded)
curl -X 'GET' \
  'https://api.retab.com/v1/extractions?limit=50&from_date=2024-01-01T00:00:00&to_date=2024-12-31T00:00:00&metadata=%7B%22source%22%3A%22docs%22%7D' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer <your-api-key>'

{
  "data": [
    {
      "id": "extr_01G34H8J2K",
      "created_at": "2024-03-15T10:30:00Z",
      "file": {
        "id": "file_6dd6eb00688ad8d1",
        "filename": "invoice.pdf"
      },
      "output": {
        "invoice_number": "INV-2024-0042",
        "total_amount": 1234.56
      },
      "json_schema": {
        "type": "object",
        "properties": {
          "invoice_number": { "type": "string" },
          "total_amount": { "type": "number" }
        }
      },
      "metadata": {}
    }
  ],
  "list_metadata": {
    "before": null,
    "after": "extr_01G34H8J2K",
    "total_count": 150
  }
}

Authorizations

Authorization

string

header

required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Query Parameters

before

string | null

after

string | null

limit

integer

default:10

Required range: 1 <= x <= 100

order

enum<string>

default:desc

Available options:

asc,

desc

filename

string | null

filename_regex

string | null

Deprecated alias for prefix filename filtering. Regex patterns are rejected.

filename_contains

string | null

Plain-text search over the filename.

document_type

string[] | null

Filter by document type. Can be repeated. Accepted values: bmp, csv, doc, docm, docx, dotm, dotx, eml, gif, heic, heif, htm, html, jpeg, jpg, json, md, mhtml, msg, odp, ods, odt, ots, ott, pdf, png, ppt, pptx, rtf, svg, tif, tiff, tsv, txt, webp, xlam, xls, xlsb, xlsm, xlsx, xltm, xltx, xml, yaml, yml.

status

enum<string> | null

Available options:

pending,

queued,

in_progress,

completed,

failed,

cancelled

from_date

string | null

to_date

string | null

metadata

string | null

Response

Successful Response

A page of Extraction resources. data holds the items and list_metadata carries the before/after cursors; pass after to fetch the next page.

data

Extraction · object[]

required

Show child attributes

list_metadata

ListMetadata · object

required

Boundary resource IDs for page navigation.

Show child attributes