Table Extractor Skill Overview This skill enables precise extraction of tables from PDF documents using camelot - the gold standard for PDF table extraction. Handle complex tables with merged cells, borderless tables, and multi-page layouts with high accuracy. How to Use Provide the PDF containing tables Optionally specify pages or table detection method I'll extract tables as pandas DataFrames Example prompts: "Extract all tables from this PDF" "Get the table on page 5 of this report" "Extract borderless tables from this document" "Convert PDF tables to Excel format" Domain Knowledge camelot Fundamentals import camelot

Extract tables from PDF

tables

camelot . read_pdf ( 'document.pdf' )

Access results

print ( f"Found { len ( tables ) } tables" )

Get first table as DataFrame

df

tables [ 0 ] . df print ( df ) Extraction Methods Method Use Case Description lattice Bordered tables Detects table by lines/borders stream Borderless tables Uses text positioning

Lattice method (default) - for tables with visible borders

tables

camelot . read_pdf ( 'document.pdf' , flavor = 'lattice' )

Stream method - for borderless tables

tables

camelot . read_pdf ( 'document.pdf' , flavor = 'stream' ) Page Selection

Single page

tables

camelot . read_pdf ( 'document.pdf' , pages = '1' )

Multiple pages

tables

camelot . read_pdf ( 'document.pdf' , pages = '1,3,5' )

Page range

tables

camelot . read_pdf ( 'document.pdf' , pages = '1-5' )

All pages

tables

camelot . read_pdf ( 'document.pdf' , pages = 'all' ) Advanced Options Lattice Options tables = camelot . read_pdf ( 'document.pdf' , flavor = 'lattice' , line_scale = 40 ,

Line detection sensitivity

copy_text

[ 'h' , 'v' ] ,

Copy text across merged cells

shift_text

[ 'l' , 't' ] ,

Shift text alignment

split_text

True ,

Split text at newlines

flag_size

True ,

Flag super/subscripts

strip_text

'\n' ,

Characters to strip

process_background

False ,

Process background lines

) Stream Options tables = camelot . read_pdf ( 'document.pdf' , flavor = 'stream' , edge_tol = 500 ,

Edge tolerance

row_tol

10 ,

Row tolerance

column_tol

0 ,

Column tolerance

strip_text

'\n' ,

Characters to strip

) Table Area Specification

Extract from specific area (x1, y1, x2, y2)

Coordinates from bottom-left, in PDF points (72 points = 1 inch)

tables

camelot . read_pdf ( 'document.pdf' , table_areas = [ '72,720,540,400' ] ,

One area

)

Multiple areas

tables

camelot . read_pdf ( 'document.pdf' , table_areas = [ '72,720,540,400' , '72,380,540,200' ] , ) Column Specification

Manually specify column positions (for stream method)

tables

camelot . read_pdf ( 'document.pdf' , flavor = 'stream' , columns = [ '100,200,300,400' ] ,

X positions of column separators

) Working with Results import camelot tables = camelot . read_pdf ( 'document.pdf' ) for i , table in enumerate ( tables ) :

Access DataFrame

df

table . df

Table metadata

print ( f"Table { i + 1 } :" ) print ( f" Page: { table . page } " ) print ( f" Accuracy: { table . accuracy } " ) print ( f" Whitespace: { table . whitespace } " ) print ( f" Order: { table . order } " ) print ( f" Shape: { df . shape } " )

Parsing report

report

table . parsing_report print ( f" Report: { report } " ) Export Options import camelot tables = camelot . read_pdf ( 'document.pdf' )

Export to CSV

tables [ 0 ] . to_csv ( 'table.csv' )

Export to Excel

tables [ 0 ] . to_excel ( 'table.xlsx' )

Export to JSON

tables [ 0 ] . to_json ( 'table.json' )

Export to HTML

tables [ 0 ] . to_html ( 'table.html' )

Export all tables

for i , table in enumerate ( tables ) : table . to_excel ( f'table_ { i + 1 } .xlsx' ) Visual Debugging import camelot

Enable visual debugging

tables

camelot . read_pdf ( 'document.pdf' )

Plot detected table areas

camelot . plot ( tables [ 0 ] , kind = 'contour' ) . show ( )

Plot text on table

camelot . plot ( tables [ 0 ] , kind = 'text' ) . show ( )

Plot detected lines (lattice only)

camelot . plot ( tables [ 0 ] , kind = 'joint' ) . show ( ) camelot . plot ( tables [ 0 ] , kind = 'line' ) . show ( )

Save plot

fig

camelot . plot ( tables [ 0 ] ) fig . savefig ( 'debug.png' ) Handling Multi-page Tables import camelot import pandas as pd def extract_multipage_table ( pdf_path , pages = 'all' ) : """Extract and combine tables that span multiple pages.""" tables = camelot . read_pdf ( pdf_path , pages = pages )

Group tables by similar structure (columns)

table_groups

{ } for table in tables : cols = tuple ( table . df . columns ) if cols not in table_groups : table_groups [ cols ] = [ ] table_groups [ cols ] . append ( table . df )

Combine similar tables

combined

[ ] for cols , dfs in table_groups . items ( ) : if len ( dfs )

1 :

Combine and deduplicate header rows

combined_df

pd

.

concat

(

dfs

,

ignore_index

=

True

)

combined

.

append

(

combined_df

)

else

:

combined

.

append

(

dfs

[

0

]

)

return

combined

Best Practices

Try Both Methods

Lattice for bordered, stream for borderless

Check Accuracy Score

Above 90% is usually good

Use Visual Debugging

Understand extraction results

Specify Areas

For PDFs with multiple table types

Handle Headers

First row often needs special treatment Common Patterns Batch Table Extraction import camelot from pathlib import Path import pandas as pd def batch_extract_tables ( input_dir , output_dir ) : """Extract tables from all PDFs in directory.""" input_path = Path ( input_dir ) output_path = Path ( output_dir ) output_path . mkdir ( exist_ok = True ) results = [ ] for pdf_file in input_path . glob ( '*.pdf' ) : try : tables = camelot . read_pdf ( str ( pdf_file ) , pages = 'all' ) for i , table in enumerate ( tables ) :

Skip low accuracy tables

if table . accuracy < 80 : continue output_file = output_path / f" { pdf_file . stem } table { i + 1 } .xlsx" table . to_excel ( str ( output_file ) ) results . append ( { 'source' : str ( pdf_file ) , 'table' : i + 1 , 'page' : table . page , 'accuracy' : table . accuracy , 'output' : str ( output_file ) } ) except Exception as e : results . append ( { 'source' : str ( pdf_file ) , 'error' : str ( e ) } ) return results Auto-detect Table Method import camelot def smart_extract_tables ( pdf_path , pages = '1' ) : """Try both methods and return best results."""

Try lattice first

lattice_tables

camelot . read_pdf ( pdf_path , pages = pages , flavor = 'lattice' )

Try stream

stream_tables

camelot . read_pdf ( pdf_path , pages = pages , flavor = 'stream' )

Compare and return best

results

[ ] if lattice_tables and lattice_tables [ 0 ] . accuracy

70 : results . extend ( lattice_tables ) elif stream_tables : results . extend ( stream_tables ) return results Examples Example 1: Financial Statement Extraction import camelot import pandas as pd def extract_financial_tables ( pdf_path ) : """Extract financial tables from annual report."""

Extract all tables

tables

camelot . read_pdf ( pdf_path , pages = 'all' , flavor = 'lattice' ) financial_data = { 'income_statement' : None , 'balance_sheet' : None , 'cash_flow' : None , 'other_tables' : [ ] } for table in tables : df = table . df text = df . to_string ( ) . lower ( )

Identify table type

if 'revenue' in text or 'sales' in text : if 'operating income' in text or 'net income' in text : financial_data [ 'income_statement' ] = df elif 'asset' in text and 'liabilities' in text : financial_data [ 'balance_sheet' ] = df elif 'cash flow' in text or 'operating activities' in text : financial_data [ 'cash_flow' ] = df else : financial_data [ 'other_tables' ] . append ( { 'page' : table . page , 'data' : df , 'accuracy' : table . accuracy } ) return financial_data financials = extract_financial_tables ( 'annual_report.pdf' ) if financials [ 'income_statement' ] is not None : print ( "Income Statement found:" ) print ( financials [ 'income_statement' ] ) Example 2: Scientific Data Extraction import camelot import pandas as pd def extract_research_data ( pdf_path , pages = 'all' ) : """Extract data tables from research paper."""

Try lattice for bordered tables

tables

camelot . read_pdf ( pdf_path , pages = pages , flavor = 'lattice' ) if not tables or all ( t . accuracy < 70 for t in tables ) :

Fall back to stream for borderless

tables

camelot . read_pdf ( pdf_path , pages = pages , flavor = 'stream' ) extracted_data = [ ] for table in tables : df = table . df

Clean up the DataFrame

Set first row as header if it looks like one

if not df . iloc [ 0 ] . str . contains ( r'\d' ) . any ( ) : df . columns = df . iloc [ 0 ] df = df [ 1 : ] df = df . reset_index ( drop = True ) extracted_data . append ( { 'page' : table . page , 'accuracy' : table . accuracy , 'data' : df } ) return extracted_data data = extract_research_data ( 'research_paper.pdf' ) for i , item in enumerate ( data ) : print ( f"Table { i + 1 } (Page { item [ 'page' ] } , Accuracy: { item [ 'accuracy' ] } %):" ) print ( item [ 'data' ] . head ( ) ) Example 3: Invoice Line Items import camelot def extract_invoice_items ( pdf_path ) : """Extract line items from invoice."""

Usually invoices have bordered tables

tables

camelot . read_pdf ( pdf_path , flavor = 'lattice' ) line_items = [ ] for table in tables : df = table . df

Look for table with typical invoice columns

header_text

' ' . join ( df . iloc [ 0 ] . astype ( str ) ) . lower ( ) if any ( term in header_text for term in [ 'quantity' , 'qty' , 'amount' , 'price' , 'description' ] ) :

This looks like a line items table

df . columns = df . iloc [ 0 ] df = df [ 1 : ] for _ , row in df . iterrows ( ) : item = { } for col in df . columns : col_lower = str ( col ) . lower ( ) value = row [ col ] if 'desc' in col_lower or 'item' in col_lower : item [ 'description' ] = value elif 'qty' in col_lower or 'quantity' in col_lower : item [ 'quantity' ] = value elif 'price' in col_lower or 'rate' in col_lower : item [ 'unit_price' ] = value elif 'amount' in col_lower or 'total' in col_lower : item [ 'amount' ] = value if item : line_items . append ( item ) return line_items items = extract_invoice_items ( 'invoice.pdf' ) for item in items : print ( item ) Example 4: Table Comparison import camelot import pandas as pd def compare_pdf_tables ( pdf1_path , pdf2_path ) : """Compare tables between two PDF versions.""" tables1 = camelot . read_pdf ( pdf1_path ) tables2 = camelot . read_pdf ( pdf2_path ) comparisons = [ ]

Match tables by shape and position

for t1 in tables1 : best_match = None best_score = 0 for t2 in tables2 : if t1 . df . shape == t2 . df . shape :

Calculate similarity

try : similarity = ( t1 . df == t2 . df ) . mean ( ) . mean ( ) if similarity

best_score : best_score = similarity best_match = t2 except : pass if best_match : comparisons . append ( { 'page1' : t1 . page , 'page2' : best_match . page , 'similarity' : best_score , 'identical' : best_score == 1.0 , 'diff' : pd . DataFrame ( t1 . df != best_match . df ) } ) return comparisons comparison = compare_pdf_tables ( 'report_v1.pdf' , 'report_v2.pdf' ) Limitations Encrypted PDFs not supported Image-based PDFs need OCR preprocessing Very complex merged cells may need tuning Rotated tables require preprocessing Large PDFs may need page-by-page processing Installation pip install camelot-py [ cv ]

Additional dependencies

macOS

brew install ghostscript tcl-tk

Ubuntu

apt-get install ghostscript python3-tk Resources camelot Documentation GitHub Repository Comparison with Other Tools