Need help with textricator?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

279 Stars 30 Forks GNU Affero General Public License v3.0 79 Commits 7 Opened issues


Textricator is a tool to extract text from documents and generate structured data.

Services available


Need anything else?

Contributors list


Textricator is a tool to extract text from documents and generate structured data.

If you have a bunch of PDFs with the same format (or one big, consistently formatted PDF) and you want to extract the data to CSV or JSON, Textricator can help! It can even work on OCR'ed documents!

Textricator is released under the GNU Affero General Public License Version 3.

Textricator is deployed to Maven Central with GAV


This application is actively used and developed by Measures for Justice. We welcome feedback, bug reports, and contributions. Create an issue, send a pull request, or email us at [email protected]. If you use Textricator, please let us know. Send us your mailing address and we will mail you a sticker.

is the main entry point for library usage.

is the command-line interface.

The CLI has three subcommands, to use the three main features of Textricator: * text - Extract text from the PDF and generate JSON. * table - Parse the text that is in columns and rows. See Table section. * form - Parse the text with a configured finite state machine. See Form section.

Quick Start

  • Install Java (version 8+)
    • Windows & Macos: Download from and install.
    • Linux: Use your package manager.
  • Download the latest build of Textricator from - click on the directory for the latest version and download
    for Windows).
  • Extract it.
  • Run a shell
    • Windows: run Windows Powershell (it should be in the start menu)
    • The following examples start with
      . On Windows, use
    • MacOS: Run Terminal (type "terminal" in Spotlight)
  • Show help
    • ./textricator --help
  • Download the example files to the textricator directory:
  • Extract raw text from a PDF to standard out
    • ./textricator text --input-format=pdf.pdfbox school-employee-list.pdf
  • Parse a PDF to CSV
    • ./textricator form --config=school-employee-list.yml school-employee-list.pdf school-employee-list.csv
      • This uses the configuration file
        to parse
        . To parse your own PDF form, you will need to write your own configuration file. See the Form section for details. If your PDF has a tabular layout, see the Table section.

Illegal Reflective Access Warning

You may see the following warning printed:

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by org.parboiled.transform.AsmUtils (file:/F:/pathto/lib/parboiled-java-1.3.1.jar) to method java.lang.ClassLoader.findLoadedClass(java.lang.String)
WARNING: Please consider reporting this to the maintainers of org.parboiled.transform.AsmUtils
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release

Textricator still works, it is just a warning printed by a library Textricator uses. See Issue #18.

Extracting text

To extract the text from a PDF, run

textrictor text --input-format=pdf.itext5 input.pdf input-text.csv
for any
and then open
in your favorite spreadsheet program. It will show you every bit of text that Textricator sees with its position, size, and font information. This information is very useful for building configuration to parse tables or forms using Textricator (see the following two sections).


to see how Textricator extracts the texts using the different parser engines. Some work better for some documents than others.


In table mode, the data is grouped into columns based on the x-coordinate of the text.


This is an example for

# All measurements are in points. 1 point = 1/72 of an inch.
# x-coordinates are from the left edge of the page.
# y-coordinates are from the top edge of the page.

Use the built-in pdfbox extractor

extractor: "pdf.pdfbox"

Ignore everything above 88pt from the top

top: 88

Ignore everything below 170pt from the top

bottom: 170

If multiple text segments are withing 2pt vertically, consider them in the same row.

maxRowDistance: 2

Define the columns, based on the x-coordinate where the column starts:

cols: "name": 0 "launched": 132 "speed": 235 "cospar": 249 "power": 355 "mass": 415

types: "name": label: "Name"

"launched": label: "Launch Date"

"speed": label: "Speed (km/s)" type: "number"

"cospar": label: "COSPAR ID"

"power": label: "Power (watts)" type: "number"

"mass": label: "Mass (pounds)" # Add .0 to the end of mass replacements: - pattern: "^(.*)$" replacement: "$1.0"

Omit if Power is less than 200

filter: 'power >= 200'


In form mode, the data is parsed by Textricator using a finite-state machine (FSM), and the FSM and additional parsing and formatting parameters are configured with YAML, indicated by command line option



State transitions are selected by evaluating conditions. Conditions are expressions parsed by Expr.

Available variables:

  • ulx
    - x coordinate of the upper-left corner of the text box
  • uly
    - y coordinate of the upper-left corner of the text box
  • lrx
    - x coordinate of the lower-right corner of the text box
  • lry
    - y coordinate of the lower-right corner of the text box
  • text
    - the text
  • page
    - page number
  • page_prev
    - page number of the previous text
  • fontSize
    - font size
  • font
    - font name
  • color
    - text color
  • bgcolor
    - background color
  • width
    - width of the text box
  • height
    - height of the text box
  • ulx_rel
    - difference in
    between the previous and current texts
  • uly_rel
    - difference in
    between the previous and current texts
  • lrx_rel
    - difference in
    between the previous and current texts
  • lry_rel
    - difference in
    between the previous and current texts
  • added Variables


This is an example for

# Use the built-in pdfbox parser
extractor: "pdf.pdfbox"

All measurements are in points. 1 point = 1/72 of an inch.

x-coordinates are from the left edge of the page.

y-coordinates are from the top edge of the page.

header: # ignore anything less than this many points from the top, default and per-page default: 130 footer: # ignore anything less than this many points from the bottom, default and per-page default: 700

Text segments are generally parsed in order, top to bottom, left to right.

If two text segments have y-coordinates within this many points, consider them on the same line,

and process the one further left first, even if it is 0.4pt lower on the page.

maxRowDistance: 2

Define the output data record.

Since the main record type we're collecting information on is our employees,

we'll have that be the root type for our harvested information.

rootRecordType: employee recordTypes: employee: label: "employee" # Labels are used when nested recordTypes come into play, like this document. valueTypes: # Not sure what to name a valueType? Just make something up! - employee - name - hiredate - occupation - showinfo - bool1 - bool2 - bool3 - salary children: # In this example, there are multiple children nested under an employee, # so we'll treat it as a 'child' to the 'employee' recordType. - child child: label: "child" valueTypes: - child - grade

valueTypes: employee: # In the CSV, use "Employee ID" as the column header instead of "employee". label: "Employee ID" name: label: "Name" hiredate: label: "Hire Date" occupation: label: "Occupation" salary: label: "Salary" showinfo: label: "Important Info?" bool1: label: "Boolean 1" bool2: label: "Boolean 2" bool3: label: "Boolean 3" child: label: "Attending Child" grade: label: "Grade"

Now we define the finite-state machine

Let's name the state that our machine starts off with:

initialState: "INIT"

When each text segment is encountered, each transition for the current state is checked.

states: INIT: transitions: # The first bit of text we reach is 'ID-0001', so we'll try the only transition that should work here. - # If this condition matches (which it should) condition: employee # Curious about the condition? Sxroll further down to the conditions section of this YAML. # Then we'll switch to the 'employee' state! nextState: employee

employee: # ID number with the format 'ID-####' startRecord: true # When we enter this stage, we'll create a new "case" record. transitions: - # Now we move on to the name label. Once again, by varifying the condition and moving on after that. condition: namelabel nextState: namelabel

namelabel: include: false # The label isn't important information in and of itself, so we can just not include it in the data. transitions: - condition: name nextState: name

name: transitions: - # Sometimes a name will be in two segments, and we'll hit another 'name' text segment before anything else. # In that case, a state can transition to itself, compounding the information picked up in it. condition: name nextState: name - # Does the first condition not match the text? We move onto the next one. condition: hiredateLabel nextState: hiredateLabel

hiredateLabel: include: false transitions: - condition: hiredateLabel nextState: hiredateLabel - condition: hiredate nextState: hiredate

hiredate: transitions: - condition: occupationLabel nextState: occupationLabel

occupationLabel: include: false transitions: - condition: occupation nextState: occupation

occupation: transitions: - condition: occupation nextState: occupation - # This state and the next are an example of how you can choose, using conditions, what to include or not. # They share the same area of a document, but have qualities to them that can be distinguishable. # Does it meet 'showinfo' conditions? Then we go to the 'showinfo' state that includes it. condition: showinfo nextState: showinfo - # Doesn't meet 'showinfo'? Then check for 'notinfo' and exclude it. condition: notinfo nextState: notinfo showinfo: transitions: - condition: showinfo nextState: showinfo - condition: bool1 nextState: bool1 notinfo: include: false transitions: - condition: notinfo nextState: notinfo - condition: bool1 nextState: bool1

bool1: transitions: - condition: bool2 nextState: bool2 bool2: transitions: - condition: bool3 nextState: bool3 bool3: transitions: - condition: salaryLabel nextState: salaryLabel

salaryLabel: include: false transitions: - condition: salary nextState: salary

salary: transitions: - condition: childrenLabel nextState: childrenLabel - condition: employee nextState: employee - condition: end nextState: end

childrenLabel: include: false transitions: - condition: childrenLabel nextState: childrenLabel - condition: childLabel nextState: childLabel

childLabel: include: false transitions: - condition: child nextState: child

child: # Here we reach a datatype nested within another datatype. We can start records using this child datatype. # In the process, we'll be making multiple rows for the parent datatype, each one holding onto it's own child. startRecord: true transitions: - condition: child nextState: child - condition: gradeLabel nextState: gradeLabel - condition: childLabel nextState: childLabel

gradeLabel: include: false transitions: - # Normally, there would always been an instance of a grade appearing right after the label. # But in this document, we have one instance of that not happening under ID-0007's child. condition: grade nextState: grade - # So we just account for that possibility by adding a transition out of the label. condition: employee nextState: employee

grade: transitions: - condition: employee nextState: employee - condition: childLabel nextState: childLabel - # Reach the end of the usable info in a document, but there's still text left to go? # An easy fix is to just create a looping, not-included state to finish the document off. condition: end nextState: end

end: # We reached a point in the document where all the useful information is gone, but we still have text to go. include: false transitions: - # By using an always-true condition such as 'any', we can loop this state until the document has been completely gone through. condition: any nextState: end

Here we define the conditions:


An example of comparing text with regex.

In this case, we're making sure that the text contains the characters 'ID-' followed by any amount of numbers.

employee: 'text =~ /ID-(\d)*/'

You can match based on the x- and y- coordinates of the upper left and lower right corners of the rectangle

containing the text. ulx = Upper-Left X-coordinate. lry = Lower-Right Y-coordinate. Also uly and lrx.

You can define the lower and upper limit for each, inclusive.

namelabel: '70 < ulx < 80 and font = "BCDFEE+Calibri-Bold"'

You can also match based on the type of font used, including if it was bolded or italicized.

name: '112 < ulx < 200 and font = "BCDEEE+Calibri"'

hiredateLabel: '230 < ulx < 270 and font = "BCDFEE+Calibri-Bold"'

hiredate: '280 < ulx < 290 and font = "BCDEEE+Calibri"'

occupationLabel: '391 < ulx < 393 and font = "BCDFEE+Calibri-Bold"'

occupation: '394 < ulx < 700 and font = "BCDEEE+Calibri"'

showinfo: 'font = "BCDJEE+Georgia"'

notinfo: 'font = "BCDEEE+Calibri"'

bool1: 'font = "BCDIEE+Cambria"'

bool2: 'font = "BCDIEE+Cambria"'

bool3: 'font = "BCDIEE+Cambria"'

salaryLabel: '391 < ulx < 393 and font = "BCDFEE+Calibri-Bold"'

salary: '394 < ulx < 700 and font = "BCDEEE+Calibri"'

childrenLabel: '70 < ulx < 140 and font = "BCDFEE+Calibri-Bold" and text =~ /(Attending)|(Children:)/'

childLabel: '230 < ulx < 240 and font = "BCDFEE+Calibri-Bold"'

child: '230 < ulx < 380 and font = "BCDEEE+Calibri"'

gradeLabel: '391 < ulx < 393 and font = "BCDFEE+Calibri-Bold"'

grade: '394 < ulx < 700 and font = "BCDEEE+Calibri"'

You can also match based on the size of the font and on specific text.

end: 'fontSize = 16.0 and text = "TOTAL:"'

Need a condition that is always true? "1=1" does that for you.

any: "1 = 1"

Advanced functionality

Regex matching

You can use regular expression matching instead of exact string matching in conditions:

  caseTypeLabel: 'text =~ /Case Type:?/' # maybe sometimes they forgot the ":"

Font matching

You can match font and font size:

  helvetica8: 'font =~ /.*Helvetica.*/ and fontSize = 8'

Page number matching

You can match the page number

  # Match the textbox that starts at 100pt,120pt on page 9.
  specificTextbox: 'page = 9 and ulx = 100 and uly = 120'

Requiring intermediate state

There may be cases where you want to transition from state "B" to state "A" and start a new record, but ONLY if you were in state "C" since last starting a new record:

    startRecord: true
    startRecordRequiredState: C
    # ...

Combining states

You may have 2 different states that you want to combine into one column in the output:

    label: "Record"
      - A
      # no A2
      - B

states: A: # ... A2: valueTypes: [ A ] # combine this with state "A". # ...

Joining text segments in a state

When there are multiple text segments in the same state, by default they are concatenated with a space in between. Any string, including an empty string, can be used as the separator:

    # concatenate without spaces between
    label: "Record ID"
    separator: ""
    # put newlines between text segments
    label: "Description"
    separator: "

Exclude types from output

A value type (

) can be excluded from the output. This is useful if the type is repeated on the PDF and needed as a data type to set new records, but should not be in the output.
    include: false

Relative offsets

Conditions can evaluate coordinates relative to the coordinates of the previous text. This is useful for matching only something on the next line:

maxRowDistance: 2
  # These should generally be the same (absolute value) as maxRowDistance
  descriptionSameLine: '-2 <= uly_rel <= 2'
  descriptionOneLineDown: '12 <= uly_rel <= 16' # for 12pt, single-spaced font.

Control which page number in output

If a complex data record spans multiple pages, which page number is used for the output can be controlled. Each type (

) has a page priority (default: 0). The page number for the record comes from the type with the highest priority.
    label: "Agency"
      - agencyName
      - case
    # Agency may span hundreds of pages
    # default page priority of 0
    label: "Case"
      - caseNumber
      - name
      - charge
    # Case record may span multiple pages.
    # Higher priority than agency but lower than charges,
    so case is used if there are no charges.
    pagePriority: 1
    label: "Charge"
      - chargeNumber
    # Highest priority. Use charge's page number.
    pagePriority: 2

Starting new records for each value


Regex replacement of values

Sometimes the value contains a label, or other text you want to remove. In a

, add a
, which has a
, which is a regular expression with capturing groups, and
, which is a replacement string with group references. See
for details.
# Replace "Bond Agency: Fred's Bonds" with "Fred's Bonds"
    label: "Bond Agency"
        pattern: "Bond Agency:\ *(.*)"
        replacement: "$1"


On entering a state, a variable can be set.


, add a
, which has
of the variable and the
to set.

If the

starts with
and ends with
, the content can be any built-in variable or previously set
- the same things usable as variables for conditions.

For example: a condition checks that has the same background color as the last caseNo:

        name: "lastCaseBgColor"
        value: "{bgcolor}"

conditions: sameBgColor: > 145 <= ulx and fontSize = 8 and bgcolor = lastCaseBgColor

Splitting one PDF field into multiple CSV columns

One field in the PDF can be broken up into multiple columns in the CSV file, based on different regular expressions and replacements:

# Take a field that contains lastName,firstName and split it into 2 fields - lastName and firstName
    label: "inmateName"
      - lastName
      - firstName

valueTypes: lastName: label: "Last Name" replacements: - # lastName column will contain what's before comma pattern: "(.),." replacement: "$1" firstName: label: "First Name" replacements: - # firstName column will contain what's after comma pattern: ".,(.)" replacement: "$1"

states: name: # when FSM hits state "name", split data into lastName and firstName valueTypes: - lastName - firstName


If the text is a hyperlink, the URL can be used intead of the text by setting


This is supported only by the

    label: "Company"
      - name
      - website

valueTypes: name: label: "Company Name" website: label: "Website" attribute: url # use the link URL instead of the text.

states: name: # Put the value in both "name" and "website" to get both the # text and the url into the output. valueTypes: - name - website

Filtering records

Records can be filtered before output by setting a filter on the

. Root records with a non-matching filter will not be output. Child records with a non-matching filter will be removed from their parent - the root will still be output.

Filters are expressions parsed by Expr

The variables are the fields in the record. The default type for variables is

. The type can be set by setting
in the
    label: "Case"
    # Only include cases in 2009-2013
    filter: "2009 <= year <= 2013"
      - year
      - name
      - charge
    label: "Charge"
    # omit charges of type "dummy"
    filter: >
      not( type = "dummy" )
      - code
      - type

valueTypes: year: type: number

Filtering happens after replacements and before member include checking. This allows splitting a field (e.g.: extracting a year from a date) to use in the filter, and not including the split field in the output.


Extractors extract text (instances of

) from a source. There are four included extractors:
  • pdf.pdfbox - Extract text from PDF files using Apache PDFBox.
  • pdf.itext5 - Extract text from PDF files using iText 5.
  • pdf.itext7 - Extract text from PDF files using iText 7.
  • json - Parse text from the JSON format generated by the "text" subcommand of the CLI and by

Other extractors modules may be loaded, which may support different source types, capture different information or split the text up differently. An extractor module is loaded by adding a properties file

to the classpath with a single property - the key is the extractor name and the value is the fully-qualified class name of an implementation of
. Typically an extractor module will be distributed as a JAR that includes

Indicate which extractor to use by setting

in the yaml configuration, or overriding it by passing the extractor name to the
option. If the extractor is not specified and the input is PDF,
is used.


Textricator's version is of the format

The major number is incremented for breaking changes or major new features.

The minor number is incremented for minor new features.

The build number is generated by Measures for Justice's private CI tool. It is incremented for each build, regardless of the major and minor numbers (it does not reset to zero when minor or major numbers are increased).


Much credit is due to some people who do not show up in the commit history:

  • Joe Hale, for the original idea and prototype
  • John Castaneda and Abbie Miehle who, as the first end users, provided excellent bug reports, improvements, documentation, and examples.


We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.