copy table from pdf to excel efficiently with precision

Table of Contents
- Technical Challenges and Methodologies in PDF Table Extraction
- Layout Inconsistencies and Structural Variability in PDF Tables
- Comparison of PDF Table Structures: Text-Based vs. Vector-Based Representations
- Flowchart: Isolating a Table Within a PDF Document
- PDF Encoding Types and Their Impact on Table Extraction
- Real-World PDF Table Examples and Their Complexity
- Tools and Software for Converting PDF Tables to Excel
- Core Algorithms in PDF Table Extraction
- Ranked List of Tools for PDF-to-Excel Conversion
- Step-by-Step Guide: Extracting Tables with Python Libraries
- 1. Camelot-py: Lattice and Stream Modes
- Use images in Camelot for better line detection
- 2. Tabula-py: Lightweight Table Extraction
- Manual Methods for Precise Table Extraction from PDFs to Excel
- Using Adobe Acrobat’s "Paste as Text" Method for Basic Table Extraction
- Step-by-Step Guide for Transcribing Complex Tables with Formulas or Conditional Formatting
- Excel’s "Get Data" Feature for Direct PDF Table Import with Troubleshooting
- OCR Tools for Scanned PDF Tables: ABBYY FineReader and Accuracy Settings
- Data Cleaning and Formatting Post-Extraction
- Automated Data Cleaning with Python Scripts
- Read Excel file into DataFrame
- Example: Replace merged cells with a placeholder (e.g., "Merged")
- Structured Approach to Manual Cleaning in Excel
- Documenting Data Cleaning Rules with an HTML Table Template
- Advanced Techniques for Specialized PDF Tables
- Extracting Tables from PDF Forms and Interactive Documents
- Process JavaScript-triggered text (requires DOM parsing)
- Parsing Multi-Page Tables Across PDF Documents
- Extracting Tables with Embedded Images or Graphs
- Case Study: Extracting Hierarchical Tables from PDFs
- Performance Comparison: OCR vs. Direct Parsing for Low-Resolution Tables
Converting tables from PDFs to Excel presents a critical challenge for professionals handling data-driven workflows, where accuracy and efficiency determine operational success. The process involves navigating technical complexities, from parsing inconsistently formatted tables to resolving merged cells and encoding discrepancies, all of which directly impact data integrity. This guide explores systematic methodologies, from automated tools to manual techniques, ensuring seamless extraction while preserving structural and contextual accuracy. By addressing both foundational principles and advanced strategies, it equips users with actionable solutions to streamline conversions and mitigate common pitfalls.
PDF tables often defy straightforward extraction due to their diverse structures—ranging from text-based layouts to vector-based designs—which demand tailored approaches for optimal results. Whether leveraging Python libraries like camelot-py or manual methods such as Adobe Acrobat’s "Paste as Text," each technique introduces trade-offs between speed, precision, and adaptability. The discussion further dissects post-extraction challenges, including data cleaning and formatting, to deliver actionable frameworks for maintaining consistency across converted datasets. For industries reliant on structured data, mastering these processes is indispensable for reducing manual errors and enhancing decision-making.

Technical Challenges and Methodologies in PDF Table Extraction
Extracting tables from PDF documents presents a unique set of challenges due to the underlying structure and encoding of PDF files. Unlike structured formats such as CSV or Excel, PDFs often embed tables as part of a complex layout, combining text, graphics, and vector-based elements. This heterogeneity complicates automated parsing, as tools must account for variations in formatting, encoding, and spatial relationships between cells. The accuracy of extraction hinges on understanding these technical intricacies, from the low-level representation of content streams to the high-level interpretation of merged cells and nested headers.
The process of isolating and converting PDF tables requires a multi-step workflow that integrates optical character recognition (OCR), spatial analysis, and rule-based heuristics. Below, the technical challenges are dissected, followed by a structured comparison of PDF table structures and their implications for extraction tools.
Layout Inconsistencies and Structural Variability in PDF Tables
PDF tables exhibit significant variability in design, ranging from simple grid layouts to highly complex nested structures. Key challenges include:These inconsistencies necessitate adaptive parsing strategies, such as dynamic thresholding for boundary detection or machine learning-based segmentation to classify merged regions.
Comparison of PDF Table Structures: Text-Based vs. Vector-Based Representations
PDF tables are encoded using two primary structural paradigms, each with distinct implications for extraction accuracy:| Feature | Text-Based Tables | Vector-Based Tables |
|---|---|---|
| Encoding Method | Text rendered as part of content streams. | Geometric shapes (paths, lines) defining cells. |
| Extraction Complexity | Higher; relies on OCR for text extraction. | Lower; coordinates can be directly parsed. |
| Formatting Preservation | Poor; formatting (bold, italics) may degrade. | Excellent; retains strokes, fills, and layers. |
| Merged Cell Handling | Difficult; requires post-processing. | Easier; paths can encode merged regions. |
| Example Use Case | Scanned documents, legacy PDFs. | CAD diagrams, architectural plans. |
Flowchart: Isolating a Table Within a PDF Document
The following steps outline the procedural workflow for table extraction, from raw PDF input to structured output:1. PDF Preprocessing
2. Table Localization
3. Boundary Refinement
4. Content Extraction
5. Structural Validation
6. Output Generation
Visual Representation (Descriptive):
A flowchart would depict these steps as a linear pipeline, with feedback loops for preprocessing adjustments (e.g., re-binarization if OCR accuracy is low). Decision nodes would include checks for vector vs. text dominance and fallback mechanisms for ambiguous regions.
PDF Encoding Types and Their Impact on Table Extraction
PDF tables are encoded using low-level constructs defined in the PDF specification (ISO 32000). Key encoding types and their extraction implications include:- Content Streams (`/Contents`)
BT /F1 12 Tf 100 700 Td (Cell Value) Tj ET
```
(Begin text, select font, move to coordinates, show text, end text.)
- XObjects (`/XObject`)
- Form XObjects (`/Form`)
- Annotations (`/Annots`)
Extraction Strategy:
Tools like pdfminer.six or Apache PDFBox parse these constructs by:
1. Traversing the PDF object hierarchy.
2. Filtering streams for table-relevant operators (e.g., `re`, `m`, `l` for lines).
3. Reconstructing tables from spatial relationships between detected elements.
Real-World PDF Table Examples and Their Complexity
Below is a table categorizing five common PDF table structures, highlighting their extraction challenges:| Example Type | Complexity Level | Key Features | Extraction Challenges |
|---|---|---|---|
| Financial Reports | High | Multi-page tables with nested headers, merged cells for subtotals. | Dynamic column alignment; OCR errors in small font. |
| Academic Research Tables | Medium-High | Hierarchical headers (e.g., "Method" → "Submethod"), footnotes spanning columns. | Contextual header resolution; footnote placement ambiguity. |
| CAD/Engineering Drawings | Low-Medium | Vector-based tables with precise coordinates, often overlaid on diagrams. | Geometric noise from non-table lines; unit conversion for coordinates. |
| Survey Forms | Medium | Checkbox matrices, conditional logic (e.g., "If Yes, fill Row X"). | Interactive elements; logical dependencies between cells. |
| Legal Contracts | High | Dense text with inline tables (e.g., schedules), variable column widths. | Line-break ambiguity; merged clauses spanning multiple cells. |
| Medical Datasets | Medium | Tabular data with units (e.g., "mg/dL"), merged cells for patient metadata. | Unit disambiguation; OCR errors in handwritten annotations. |
1. Financial Reports: Imagine a 10-column table where the first two rows are headers (e.g., "Region" → "Q1 Sales" → "Q2 Sales"), with merged cells for regional totals. The challenge lies in distinguishing headers from data rows without prior knowledge of the schema.
2. CAD Tables: A table embedded in a blueprint might use exact coordinates (e.g., `(100,200) re`) to define cell boundaries, but adjacent dimension lines may intersect the grid, requiring spatial exclusion rules.
3. Survey Forms: A checkbox table might have cells labeled "Agree/Disagree" with radio buttons rendered as XObjects, necessitating both geometric and semantic parsing to infer selections.
Tools and Software for Converting PDF Tables to Excel
PDF-to-Excel table conversion relies on specialized algorithms to parse structured data from unstructured or semi-structured documents. Tools in this domain employ a combination of geometric analysis, text recognition, and machine learning to detect table boundaries, cell separations, and merged cells. While some solutions prioritize accuracy for well-formatted tables, others incorporate OCR (Optical Character Recognition) to handle scanned or image-based PDFs. The choice of tool depends on factors such as table complexity, batch processing needs, and integration with existing workflows.
Core Algorithms in PDF Table Extraction
The accuracy of table extraction hinges on three primary algorithms:
1. Geometric Layout Analysis
Tools like Adobe Acrobat and Tabula use contour detection to identify rectangular regions (tables) by analyzing whitespace, text density, and line patterns. Camelot, a Python library, extends this with projection-based methods, where horizontal and vertical lines are inferred from text alignment and gaps between characters.
2. Text Segmentation and Cell Separation
PDFPlumber employs word-level bounding box analysis to split cells by examining the spatial distribution of text blocks. Advanced tools (e.g., Camelot’s Lattice Mode) apply dynamic programming to resolve ambiguous separations, such as merged cells or irregular spacing.
3. OCR Integration for Scanned PDFs
Tools like Tabula and Smallpdf integrate Tesseract OCR to convert image-based PDFs into editable text before table extraction. This introduces latency but enables handling of non-selectable text in scanned documents.
Ranked List of Tools for PDF-to-Excel Conversion
Below is a ranked table of six widely used tools, categorized by accuracy, ease of use, and feature support, with strengths and limitations highlighted.| Rank | Tool | Type | Strengths | Limitations | Best For |
|---|---|---|---|---|---|
| 1 | Camelot-py | Open-source (Python) |
|
|
Developers, large-scale automated extractions. |
| 2 | Tabula-py | Open-source (Java/Python) |
|
|
Quick conversions, non-technical users. |
| 3 | Adobe Acrobat Pro | Paid (Desktop) |
|
|
Professionals needing occasional manual refinement. |
| 4 | PDFPlumber | Open-source (Python) |
|
|
Data scientists, custom pipeline integration. |
| 5 | Smallpdf | Cloud-based (Freemium) |
|
|
Non-technical users, ad-hoc conversions. |
| 6 | iLovePDF | Cloud-based (Freemium) |
|
|
Occasional users, quick sharing. |
Note: For scanned PDFs, prioritize tools with OCR integration (e.g., Tabula, Smallpdf). For programmatic use, Python libraries (Camelot, PDFPlumber) offer the most flexibility.
Step-by-Step Guide: Extracting Tables with Python Libraries
Python libraries provide programmatic control over table extraction, ideal for automation. Below are procedures for Camelot-py, Tabula-py, and PDFPlumber, including dependencies and syntax.1. Camelot-py: Lattice and Stream Modes
Dependencies:Install via pip:
pip install camelot-py[cv] opencv-python pandas
Key Features:
Example: Extract Tables from PDF
import camelot
# Extract tables (Lattice Mode)
tables = camelot.read_pdf(
"document.pdf",
pages="all",
flavor="lattice",
table_areas=["0,0,500,500"] # Optional: specify region
)
# Export to Excel
tables.export("output.xlsx", f="excel")
# Access first table as Pandas DataFrame
df = tables[0].df
print(df.head())
Handling Merged Cells:
Camelot’s `merge_strategy` parameter (e.g., `"merge"` or `"split"`) controls how merged cells are processed. For ambiguous cases, preprocess the PDF with `pdf2image` to enhance line detection:
from pdf2image import convert_from_path
images = convert_from_path("document.pdf")
Use images in Camelot for better line detection
2. Tabula-py: Lightweight Table Extraction
Dependencies:pip install tabula-py pandas
Example: Basic Extraction
import tabula
# Read PDF into DataFrames
dfs = tabula.read_pdf(
"document.pdf",
pages="all",
multiple_tables=True,
lattice=True # Enable lattice detection
)
# Export all tables to Excel
tabula.convert_into(
"document.pdf",
"

Manual Methods for Precise Table Extraction from PDFs to Excel
Manual extraction of tables from PDFs to Excel ensures accuracy when automated tools fail to preserve structural integrity, such as merged cells, conditional formatting, or complex formulas. Unlike software-dependent solutions, manual techniques allow for granular control over data alignment, cell formatting, and validation, making them essential for high-stakes datasets like financial reports, scientific tables, or legal documents. Below are systematic approaches to manually recreate PDF tables in Excel, including optimization for efficiency and troubleshooting misaligned data.Using Adobe Acrobat’s "Paste as Text" Method for Basic Table Extraction
Adobe Acrobat Pro’s "Paste as Text" feature extracts tabular data as plain text, which can then be manually formatted in Excel. This method is ideal for static tables without merged cells or nested structures. The process involves selecting the table in the PDF, copying it, and pasting it into Excel while adjusting alignment and delimiters.Step-by-Step Procedure:
1. Select the Table in PDF:
2. Copy and Paste into Excel:
3. Adjust Cell Alignment and Delimiters:
Keyboard Shortcuts for Efficiency:
Step-by-Step Guide for Transcribing Complex Tables with Formulas or Conditional Formatting
Complex tables—those containing formulas (e.g., `=SUM()`, `=VLOOKUP()`), conditional formatting (e.g., color scales, data bars), or multi-level headers—require meticulous transcription. Below is a structured approach to replicate such tables while preserving logic and visual cues.Preparation Phase:
Transcription Workflow:
1. Recreate the Structure:
2. Transcribe Data and Formulas:
3. Validate with Sample Data:
Example: Handling Multi-Level Headers
[Column A] [Column B] [Column C]
-------------|-------------|-------------
[Header 1] [Subheader] [Subheader]
Data Row 1 Value 1 Value 2
- Excel Replication:
Excel’s "Get Data" Feature for Direct PDF Table Import with Troubleshooting
Excel’s "Get Data" functionality (introduced in Excel 2016+) allows direct import of PDF tables into structured tables or ranges, reducing manual effort. However, misaligned data, missing headers, or inconsistent delimiters may require adjustments.Import Process:
1. Open Excel and Navigate to Data Tab:
2. Preview and Load:
3. Troubleshooting Common Issues:
Solution: In the Power Query Editor, select the column, go to Home > Split Column > By Delimiter, and choose a space or tab.
Optimizing for Large Tables:
OCR Tools for Scanned PDF Tables: ABBYY FineReader and Accuracy Settings
Scanned PDFs (image-based) require Optical Character Recognition (OCR) to convert text into editable formats. ABBYY FineReader is a leading tool for this purpose, offering high accuracy for tables with proper configuration.Configuration for Table Extraction:
1. Select OCR Engine Settings:
2. Adjust Accuracy Parameters:
3. Export to Excel:
Validation Checklist for OCR-Extracted Tables:
Example: Handling Low-Quality Scans
Data Cleaning and Formatting Post-Extraction
Extracted tables from PDFs often require systematic refinement to ensure accuracy, consistency, and usability in downstream analyses. Post-extraction cleaning addresses structural inconsistencies—such as misaligned columns, merged cells, or irregular data types—while preserving the integrity of the original data. This phase bridges raw extraction and actionable insights, minimizing errors that could distort analytical outcomes. Below, structured methodologies, Python-based automation, and Excel-native techniques are outlined to standardize and validate extracted tables efficiently.Automated Data Cleaning with Python Scripts
Python scripts streamline repetitive cleaning tasks, particularly when dealing with large datasets or repetitive extraction errors. The following template addresses common issues: whitespace normalization, header standardization, merged cell resolution, and data type conversion. The script leverages libraries such as `pandas`, `openpyxl`, and `tabula-py` for robust manipulation.import pandas as pd
from openpyxl import load_workbook
from tabula import read_pdf
# Load extracted Excel file (or directly from PDF if using tabula-py)
def clean_extracted_data(file_path, output_path):
Read Excel file into DataFrame
df = pd.read_excel(file_path, engine='openpyxl')# 1. Trim whitespace from all string columns
str_cols = df.select_dtypes(include=['object']).columns
df[str_cols] = df[str_cols].apply(lambda x: x.str.strip())
# 2. Standardize headers (convert to lowercase, replace spaces with underscores)
df.columns = df.columns.str.lower().str.replace(' ', '_')
# 3. Handle merged cells (requires openpyxl for Excel-specific operations)
wb = load_workbook(file_path)
ws = wb.active
for merge in ws.merged_cells.ranges:
Example: Replace merged cells with a placeholder (e.g., "Merged")
for cell in merge:df.at[cell.row - 1, cell.column - 1] = "Merged"
# 4. Convert columns to appropriate data types (e.g., dates, numbers)
date_cols = ['date_column', 'timestamp'] # Specify columns to convert
for col in date_cols:
if col in df.columns:
df[col] = pd.to_datetime(df[col], errors='coerce')
# 5. Save cleaned data
df.to_excel(output_path, index=False, engine='openpyxl')
print(f"Cleaned data saved to {output_path}")
# Example usage
clean_extracted_data('extracted_table.xlsx', 'cleaned_table.xlsx')
Key Considerations for Script Implementation:
Structured Approach to Manual Cleaning in Excel
When automation is insufficient—such as with highly irregular PDF layouts—manual techniques in Excel provide granular control. Below is a structured workflow for resolving common post-extraction issues using native Excel tools and Power Query.Context:
Manual cleaning is critical for tables with:
Step-by-Step Methodology:
-
Column Alignment Correction
Use the Text to Columns tool (Data > Text to Columns) to split misaligned data based on delimiters (e.g., tabs, commas). For tables with irregular spacing, manually adjust column widths and apply the Wrap Text option to preserve readability. -
Merged Cell Resolution
- Identify merged cells using
Format > Conditional Formatting > Highlight Cells Rules > Duplicate Values(merged cells often appear as duplicates). - Split merged cells:
- Copy the table to a new sheet.
- Use
Power Query > Home > Transform > Split Columnto separate merged content into rows or columns. - Replace merged placeholders (e.g., "N/A") with actual values from adjacent cells.
- Identify merged cells using
-
Data Type Standardization
Apply Excel formulas to enforce consistency:Example Formulas:
For large datasets, use- Convert text dates to serial numbers:
=DATEVALUE(A1)- Remove leading zeros from numeric data:
=VALUE(SUBSTITUTE(A1, "0", ""))- Trim whitespace:
=TRIM(A1)Power Query > Home > Transform > Data Typeto batch-convert columns. -
Handling Missing or Corrupted Data
- Use
Find & Select > Replaceto standardize placeholders (e.g., replace "—" with blank cells). - Flag inconsistencies with conditional formatting:
Rule Example:
Highlight cells with values > 100,000 in red:
Home > Conditional Formatting > New Rule > Format only cells that contain > 100000
- Use
Documenting Data Cleaning Rules with an HTML Table Template
Standardized documentation ensures reproducibility and collaboration. The following HTML table template captures cleaning rules, their purpose, and implementation steps. This template can be embedded in project documentation or shared as a reference for team members.| Column Name | Issue Identified | Cleaning Rule | Implementation Method | Notes |
|---|---|---|---|---|
| Product_Code | Leading/trailing spaces | Trim whitespace | Python: df['Product_Code'] = df['Product_Code'].str.strip()Excel: =TRIM(A1) |
Critical for VLOOKUP operations |
| Sales_Date | Inconsistent formats (MM/DD/YYYY vs. DD-MM-YYYY) | Convert to ISO format (YYYY-MM-DD) | Python: pd.to_datetime(df['Sales_Date'], format='%m/%d/%Y')Excel: =DATEVALUE(SUBSTITUTE(A1, "/", "-")) |
Use errors='coerce' to handle unparseable dates |
| Unit_Price | Numbers stored as text (e.g., "$10.99") | Remove currency symbols, convert to numeric | Python: df['Unit_Price'] = df['Unit_Price'].str.replace('$', '').astype(float)Excel: =VALUE(SUBSTITUTE(A1, "$", "")) |
Validate with ISNUMBER() checks |
| Region | Merged cells with multi-line descriptions | Split into separate rows | Power Query: Split Column > By Delimiter > Custom (Line Feed) |
Preserve original merged cell references in metadata |
Best Practices for Template Usage:
Advanced Techniques for Specialized PDF Tables
Specialized PDF tables present unique extraction challenges due to their complexity, such as embedded forms, interactive elements, or multi-page layouts. Direct parsing methods often fail for these cases, requiring tailored approaches combining automated tools, scripting, and manual refinement. Below are structured methodologies for handling tables in PDFs with dynamic content, spanning documents, or embedded visual elements, alongside performance comparisons for low-resolution inputs.Extracting Tables from PDF Forms and Interactive Documents
PDF forms and interactive documents often store tabular data in non-standard formats, including hidden fields or JavaScript-driven elements. These require specialized parsing to access underlying data structures.JavaScript-Based Solutions for Dynamic PDF Tables
Interactive PDFs may use embedded JavaScript to generate or modify tables dynamically. Tools like PDFtk or Ghostscript can extract raw data before rendering, but scripting is often necessary:
from pdfminer.high_level import extract_pages
from pdfminer.layout import LTTextContainer
for page_layout in extract_pages("interactive_form.pdf"):
for element in page_layout:
if isinstance(element, LTTextContainer):
Process JavaScript-triggered text (requires DOM parsing)
- Browser Automation (Selenium/Puppeteer): Render the PDF in a headless browser to capture dynamic table updates, then scrape the rendered HTML.
Handling Form Fields and Metadata
from PyPDF2 import PdfReader
reader = PdfReader("form.pdf")
for field in reader.get_fields():
print(f"Field: {field.get('/T')}, Value: {field.get('/V')}")
- Regex-Based Field Mapping: For non-standard forms, map extracted text to expected columns using regex patterns (e.g., `r"Invoice\s+(\d+)"` for invoice numbers).
Parsing Multi-Page Tables Across PDF Documents
Tables spanning multiple PDF pages or documents require stitching fragmented data while preserving row/column alignment. Python libraries like `PyPDF2` or `pdfminer.six` can merge content, but alignment logic must account for pagination breaks.Methodology for Multi-Page Table Extraction
1. Page Segmentation:
2. Row/Column Stitching:
from pdfminer.layout import LTTextBoxHorizontal
def stitch_tables(pages):
merged_rows = []
for page in pages:
for element in page:
if isinstance(element, LTTextBoxHorizontal):
merged_rows.append(element.get_text().split())
return merged_rows
3. Handling Page Breaks:
Performance Considerations
Extracting Tables with Embedded Images or Graphs
Tables overlaid on images or graphs (e.g., scanned documents) require Optical Character Recognition (OCR) to convert visual text into editable data. Hybrid approaches combine OCR with structural parsing for accuracy.OCR Workflows for Image-Based Tables
1. Preprocessing:
2. OCR Tools:
tesseract input.png output --psm 6 -l eng
- Python Integration:
import pytesseract
from PIL import Image
text = pytesseract.image_to_string(Image.open("table_image.png"), config='--psm 6')
3. Post-OCR Parsing:
Handling Graph Overlays
Case Study: Extracting Hierarchical Tables from PDFs
Hierarchical tables (e.g., nested bullet points, indented data) require preserving structural relationships during extraction. Below is a workflow for a financial report with multi-level budgets:Input Example:
Department A
Phase 2: $50K
Extraction Steps:
1. Indentation Analysis:
def parse_hierarchy(elements):
stack = []
for element in elements:
if element.x0 > stack[-1][1] if stack else 0: # Indent check
stack.append((element, element.x1))
else:
stack.pop()
2. Tree Construction:
{
"Department A": {
"Project X": {"Phase 1": "$50K", "Phase 2": "$50K"},
"Project Y": "$200K"
}
}
3. Output Formatting:
Tools Used:
Performance Comparison: OCR vs. Direct Parsing for Low-Resolution Tables
| Method | Accuracy (%) | Speed (Pages/Min) | Resolution Threshold | Best Use Case |
|---|---|---|---|---|
| Direct Parsing (`pdfminer.six`/`pdfplumber`) | 95–99 | 10–20 | 300+ DPI | Searchable PDFs with clear text layers. |
| OCR (Tesseract + Preprocessing) | 85–92 | 2–5 | 150–300 DPI | Scanned documents or image-based tables. |
| Hybrid (OCR + Structural Parsing) | 90–95 | 3–8 | 100–200 DPI | Mixed text/image tables with partial structure. |
| JavaScript DOM Sc Effective conversion of PDF tables to Excel hinges on a balanced integration of automation and manual oversight, tailored to the complexity of the source material. From selecting the right tool—whether a cloud-based service or a Python script—to refining extracted data through systematic cleaning and validation, each step plays a pivotal role in ensuring accuracy. By adopting structured workflows, professionals can mitigate risks associated with misaligned data, merged cells, or lost metadata, thereby preserving the integrity of critical information. This guide underscores that success lies not in relying on a single method but in strategically combining techniques to address the unique demands of each PDF table, ultimately transforming raw data into actionable insights. |
Leave a Comment
Comments are moderated before appearing. The data you submit is processed according to the Privacy Policy of www.linuxunplugged.com.