Picture a team where three people spend four hours every morning copying invoice data from email attachments into a Google Sheet. Vendor name, invoice number, date, line items, totals. The same twelve columns, hundreds of rows per week, mistakes caught only when the monthly reconciliation blows up. An OpenClaw agent can replace that entire process in an afternoon. The agent runs overnight, and by 8 AM the team gets a Telegram message: “47 invoices processed, 2 flagged for review, spreadsheet updated.”
This guide walks through building that pipeline from scratch. Not the theoretical version where everything works perfectly, but the real one, with the extraction failures, the field mapping headaches, and the validation rules that save you from silent data corruption. If you have a working OpenClaw installation (follow our setup guide if you do not), you can have a functioning data entry agent running by end of day.
What the Finished Pipeline Looks Like
Before getting into configuration, here is the daily cadence of a working OpenClaw data entry agent:
- Overnight (1 AM cron): OpenClaw checks your configured sources. It scans a Gmail inbox for new invoices, reads a Google Forms response sheet for submissions since yesterday, and pulls any new PDFs dropped into a shared Google Drive folder.
- Extraction (1:15 AM): For each source item, OpenClaw runs the extraction skill. It reads the document, identifies the relevant fields, and converts unstructured data into structured rows.
- Mapping and write (1:30 AM): Extracted data gets mapped to your spreadsheet columns and appended to the target Google Sheet or Airtable base. Each row includes a source reference so you can trace any entry back to its origin document.
- Validation (1:45 AM): A validation pass runs on newly added rows. Amounts checked against expected ranges, dates verified, required fields confirmed present, duplicates flagged.
- Morning summary (8 AM heartbeat): OpenClaw sends a Telegram brief with the night’s results: rows added, errors encountered, items flagged for human review.
Each step is a separate OpenClaw skill. The cron jobs chain them together. The rest of this guide covers building each one.
Setting Up Data Extraction from Email
Email is the most common data entry source. Invoices arrive as PDF attachments, order confirmations land as HTML emails, and vendor updates come as plain text with numbers buried in paragraphs.
The Email Extraction Skill
Create skills/email-data-extract.md in your OpenClaw workspace:
## Email Data Extraction Skill
When triggered:
1. Connect to Gmail via the gmail skill
2. Search for unread emails matching the configured filters:
- From: specific sender addresses or domains
- Subject: contains keywords like "invoice", "order confirmation", "statement"
- Has attachment: PDF or CSV
- Received: since last extraction run (check workspace/extraction-log.md for timestamp)
3. For each matching email:
a. If PDF attachment exists, download and extract text using pdf-read skill
b. If CSV attachment exists, parse directly
c. If no attachment, extract structured data from email body
4. From the extracted text, identify and capture these fields:
- vendor_name, invoice_number, invoice_date, due_date
- line_items (array: description, quantity, unit_price, total)
- subtotal, tax, grand_total, currency
5. Save extracted data to workspace/extraction-queue/[timestamp]-[vendor].json
6. Mark email as read
7. Log extraction to workspace/extraction-log.md with timestamp and source
The skill chains two capabilities: Gmail access (through the gmail skill from OpenClaw’s skill registry) and PDF text extraction. For PDFs with complex layouts, tables, or scanned images, we route extraction through Claude Opus 4.6 rather than a lighter model. The accuracy difference on messy invoices is significant. A clean, text-based PDF parses fine with Sonnet. A scanned invoice with handwritten notes needs Opus.
Handling Different Email Formats
The extraction skill needs to handle variety. Not every email looks the same.
For structured invoices (PDF with clear tables), the extraction is straightforward: read the PDF, identify the table structure, pull values by position. Accuracy on these typically runs above 95%.
For plain-text emails (vendor sends a price list or order summary inline), you need to tell OpenClaw what to look for. Add format examples to the skill:
## Known Email Formats
### Vendor: Acme Supplies
Format: plain text with "Invoice #" followed by number, line items as "Qty x Description @ $Price"
Example:
Invoice #4821
3 x Widget A @ $12.50
1 x Widget B @ $45.00
Subtotal: $82.50
Tax: $6.60
Total: $89.10
Adding format examples for your top 5-10 vendors eliminates most extraction errors. The agent learns the patterns and applies them without additional configuration for similar formats.
Extracting Data from PDFs and Forms
PDF Extraction
PDFs are the hardest source. The range goes from born-digital invoices (easy) to photographed receipts at an angle (painful). OpenClaw handles both, but the approach differs.
Create skills/pdf-data-extract.md:
## PDF Data Extraction Skill
When given a PDF file path:
1. Attempt text extraction first (fast, cheap)
- If extractable text contains structured data (invoice numbers, dates, amounts), use it
2. If text extraction yields garbage or empty results, fall back to vision:
- Convert PDF pages to images
- Send to Claude Opus 4.6 with vision capability
- Prompt: "Extract all invoice/receipt data from this image. Return JSON with fields: vendor_name, invoice_number, date, line_items, subtotal, tax, total"
3. Validate extracted data:
- Line item totals should sum to subtotal
- Tax should be a reasonable percentage of subtotal (0-30%)
- Date should be within the last 90 days
4. Save structured output to workspace/extraction-queue/
5. If validation fails, save to workspace/extraction-errors/ with the reason
The text-first approach matters for cost. Text extraction from a born-digital PDF uses minimal tokens. Vision extraction of a scanned document uses 10-20x more tokens because you are sending image data to the model. For a pipeline processing 50 documents per night, that cost difference adds up.
Google Forms Extraction
Google Forms is the easiest source because the data is already structured. Responses land in a linked Google Sheet, and OpenClaw reads them directly.
## Forms Data Extraction Skill
When triggered:
1. Read the Google Forms response sheet via google-sheets skill
2. Identify new rows since last extraction (compare against workspace/extraction-log.md)
3. For each new row:
- Map form fields to your target schema
- Apply any transformations (e.g., "Full Name" → split into first_name, last_name)
- Add to workspace/extraction-queue/ as JSON
4. Log the extraction with row numbers processed
The transformation step is where most people skip ahead and pay for it later. A form might collect “Company Name” but your spreadsheet column is “Organization.” A form might collect a date as “March 15, 2026” but your spreadsheet expects “2026-03-15.” Handle these in the extraction skill, not downstream.
Field Mapping: The Configuration That Makes or Breaks Your Pipeline
Field mapping is the step nobody talks about because it seems obvious. It is not. Mapping tells OpenClaw which extracted field goes into which spreadsheet column, how to transform values, and what to do when a field is missing.
The Mapping Configuration
Create workspace/field-mappings/invoice-to-sheet.md:
## Invoice to Google Sheet Field Mapping
Target: Google Sheet "Invoice Tracker 2026", Tab "Raw Data"
| Source Field | Target Column | Transform | Required | Default |
|-------------|---------------|-----------|----------|---------|
| vendor_name | A (Vendor) | Title case | Yes | — |
| invoice_number | B (Invoice #) | None | Yes | — |
| invoice_date | C (Date) | ISO 8601 (YYYY-MM-DD) | Yes | — |
| due_date | D (Due Date) | ISO 8601 | No | invoice_date + 30 days |
| grand_total | E (Amount) | Number, 2 decimal places | Yes | — |
| currency | F (Currency) | Uppercase 3-letter code | No | "USD" |
| line_items | G (Items) | Count of items | No | 0 |
| source_email | H (Source) | Email message ID | Auto | — |
| extracted_at | I (Processed) | ISO 8601 datetime | Auto | — |
## Missing Field Behavior
- If a required field is missing: move item to workspace/extraction-errors/ and skip
- If an optional field is missing: use the default value
- If the transform fails: log the error, write the raw value, flag the row
This mapping file is what separates a fragile demo from a production pipeline. Without it, OpenClaw guesses which fields go where, and it guesses differently depending on the model’s mood and the document’s format. With it, the behavior is deterministic.
Multiple Mapping Profiles
Real pipelines have multiple source types writing to the same or different sheets. Create a mapping file per source type:
workspace/field-mappings/invoice-to-sheet.mdfor vendor invoicesworkspace/field-mappings/expense-to-sheet.mdfor employee expense reportsworkspace/field-mappings/order-to-airtable.mdfor customer orders going to Airtable
The extraction skill identifies the document type and selects the correct mapping profile. Add a classification step early in the extraction:
Before extracting fields, classify the document:
- If from known vendor domain → use invoice mapping
- If subject contains "expense" → use expense mapping
- If from your e-commerce platform → use order mapping
- If unclassifiable → save to workspace/extraction-errors/unclassified/
Writing to Google Sheets and Airtable
Google Sheets via API
The write skill appends extracted, mapped data as new rows:
## Spreadsheet Write Skill
When given a batch of mapped data entries:
1. Read the target sheet to get current row count
2. For each entry in the batch:
a. Build the row array matching column order from the mapping config
b. Append to the sheet using google-sheets skill
c. Log the row number and source reference
3. After batch completes:
- Update workspace/write-log.md with count and timestamp
- If any writes failed, save failures to workspace/write-errors/
A practical detail: write in batches, not one row at a time. The Google Sheets API has rate limits (60 requests per minute per user for the default quota). A pipeline processing 100 invoices that writes one row per API call will hit the limit and start failing partway through. Batch your writes into groups of 20-50 rows per request.
Airtable via API
Airtable’s API is more forgiving on rate limits (5 requests per second) and supports batch creates of up to 10 records per request. The write skill for Airtable is similar but accounts for Airtable’s record structure:
## Airtable Write Skill
When given mapped data entries and target base/table:
1. Build record objects matching Airtable field names
2. Batch records into groups of 10
3. For each batch, POST to Airtable API:
- Endpoint: https://api.airtable.com/v0/{baseId}/{tableName}
- Auth: Bearer token from .env (AIRTABLE_API_KEY)
- Body: { "records": [{ "fields": { ... } }, ...] }
4. Log created record IDs for traceability
5. If a batch fails, retry once, then save to workspace/write-errors/
Store your Airtable API key in .env, never in the workspace. OpenClaw reads environment variables at runtime. For setup details, see our Airtable connection guide.
Validation Rules: Catching Errors Before They Compound
Automated data entry without validation is a pipe bomb with a delay timer. The errors compound silently until someone runs a report and the numbers are wrong. By then, you are debugging weeks of bad data.
Building a Validation Skill
Create skills/data-validate.md:
## Data Validation Skill
When triggered after a write batch:
1. Read the most recently added rows from the target sheet
2. For each row, run these checks:
### Required Field Checks
- Vendor name is not empty
- Invoice number is not empty
- Date is a valid date in the past 90 days
- Amount is a positive number
### Range Checks
- Amount between $1 and $500,000 (flag outliers for review)
- Tax percentage between 0% and 30%
- Line item count between 1 and 200
### Duplicate Detection
- Check if invoice_number + vendor_name combination already exists in the sheet
- If duplicate found: highlight the row in yellow, add "DUPLICATE" to notes column
### Cross-Validation
- Line item totals should sum to within $0.02 of the subtotal (rounding tolerance)
- Grand total should equal subtotal + tax (within $0.01)
3. For each failed check:
- Add a comment to the row's notes column explaining the issue
- Change the row's status column to "REVIEW"
- Add to workspace/validation-report.md
4. Summary stats:
- Total rows validated
- Rows passed
- Rows flagged for review (by reason)
The rounding tolerance on cross-validation is important. Invoice line items sometimes have rounding that does not sum perfectly. If you validate to exact-cent precision, you will flag 10-15% of legitimate invoices as errors. A $0.02 tolerance eliminates false positives without letting real errors through.
Custom Validation Rules
Every business has domain-specific validation needs. Add a section to the validation skill for yours:
### Business-Specific Rules
- Vendor "Acme Corp" invoices should never exceed $10,000 (contract limit)
- Any invoice from a new vendor (not in workspace/known-vendors.md) gets flagged for review
- Rush orders (due date within 7 days of invoice date) require manager approval flag
These rules turn the validation skill from a generic data checker into a business logic enforcer. The agent is not just entering data; it is applying the same judgment that a trained employee would.
Daily Data Entry Summaries via Heartbeat
The daily summary is what makes this pipeline manageable rather than something you have to babysit. Add this to your heartbeat.md:
## Data Entry Pipeline Status (Morning Brief)
If the current time is between 07:30 and 08:30 in my timezone:
1. Read workspace/extraction-log.md for entries from last night
2. Read workspace/validation-report.md for flagged items
3. Count: total documents processed, rows added, errors, items needing review
4. Send me a Telegram message in the Data Pipeline group:
**Data Entry Summary — [Date]**
- Documents processed: [N]
- Rows added to sheet: [N]
- Extraction errors: [N] (list sources if any)
- Validation flags: [N] (list reasons)
- Items needing your review: [N]
If items need review, include a link to the sheet filtered to status = "REVIEW"
Outside the 07:30-08:30 window, skip this section.
The summary turns data entry from a task you do into a dashboard you glance at. Most mornings the message says “52 processed, 0 errors, 0 flags” and you move on. On the mornings it says “3 extraction errors from scanned receipts,” you know exactly what needs attention and can handle it in five minutes.
For more on heartbeat configuration, see our heartbeat scheduling guide.
What This Costs to Run
The honest numbers for a pipeline processing 50-100 documents per night:
| Pipeline Stage | Model Used | Tokens Per Run | Cost Per Night |
|---|---|---|---|
| Email scanning + extraction | Claude Sonnet 4.6 | 30,000-50,000 | ~$0.60-1.00 |
| PDF extraction (text-based) | Claude Sonnet 4.6 | 5,000-10,000 | ~$0.10-0.20 |
| PDF extraction (vision/scanned) | Claude Opus 4.6 | 20,000-40,000 per doc | ~$0.50-1.00 per doc |
| Field mapping + writing | Claude Haiku | 10,000-15,000 | ~$0.02-0.03 |
| Validation pass | Claude Haiku | 5,000-10,000 | ~$0.01-0.02 |
| Heartbeat summary | Claude Haiku | 2,000-3,000 | ~$0.01 |
For a pipeline handling 50 born-digital PDFs per night, total cost runs $2-4 per night ($60-120/month). If half your documents are scanned images requiring vision extraction, expect $15-25 per night ($450-750/month). The takeaway: keep your vendors sending digital PDFs whenever possible. One scanned receipt costs as much to process as ten clean invoices.
Compare that to the human cost: three employees at four hours each is twelve person-hours per day. At even a modest $25/hour, that is $300/day or $6,500/month. The OpenClaw pipeline costs 1-10% of the manual approach depending on document quality.
Frequently Asked Questions
How do I connect OpenClaw to Google Sheets?
Install the google-sheets skill from the OpenClaw skill registry and authenticate via OAuth. The skill needs read/write access to the target spreadsheet. Store your Google service account credentials in .env and reference them in the skill configuration. The entire connection takes about 10 minutes. Our Google Sheets connection guide covers each step.
Can OpenClaw extract data from scanned PDFs and photos?
Yes, using vision-capable models. OpenClaw sends the PDF page as an image to Claude Opus 4.6, which reads the content and returns structured data. Accuracy on clean scans runs around 90-95%. Blurry photos, handwritten text, or unusual layouts drop accuracy to 70-80%. For critical documents, always route scanned PDFs through the validation skill and flag uncertain extractions for human review.
What happens when an extraction fails?
The pipeline saves the failed document to workspace/extraction-errors/ with a log entry explaining why: unreadable PDF, missing required fields, unrecognized format. The morning Telegram summary includes the error count and sources. You review the failures, fix the source if possible (ask the vendor for a digital PDF instead of a scan), and reprocess manually or adjust the extraction skill to handle the new format.
How accurate is automated data entry compared to manual?
On structured, born-digital documents, OpenClaw extraction matches or exceeds human accuracy because it does not get tired or skip fields. Expect error rates below 2% on clean invoices. The accuracy gap appears on messy, inconsistent documents where human judgment fills in context clues. The validation layer catches most remaining errors, bringing effective accuracy to 98-99% across all document types.
Can I use this with databases instead of spreadsheets?
Yes. Replace the Google Sheets or Airtable write skill with a database write skill that connects via API or direct SQL. PostgreSQL, MySQL, Supabase, and Firebase all work. The extraction, mapping, and validation stages remain identical. Only the write destination changes. For database connections, you need the appropriate skill from the registry and connection credentials in .env.
How do I handle different document formats from different vendors?
Create vendor-specific format examples in your extraction skill. For your top 10 vendors, add a section describing the expected format: where the invoice number appears, how line items are structured, whether totals include tax. OpenClaw uses these examples as parsing templates. For unknown formats, the agent falls back to general extraction and flags the result for review. After you correct a few extractions from a new vendor, add their format to the skill.
What is the maximum volume this can handle?
The bottleneck is API rate limits, not OpenClaw itself. Google Sheets allows 60 write requests per minute (batch writes of 50 rows per request means 3,000 rows per minute). Airtable allows 5 requests per second with 10 records each (50 records per second). For most businesses processing hundreds of documents per day, these limits are never reached. If you process thousands daily, consider writing to a database instead.
Key Takeaways
- An OpenClaw data entry agent is a pipeline of chained skills: extract from source, map fields, write to spreadsheet, validate, summarize. Each skill is a markdown file in your workspace, and cron jobs wire them together overnight.
- Field mapping configuration is the difference between a fragile demo and a production system. Define explicit mappings per source type with transforms, defaults, and missing-field behavior. Do not let the agent guess.
- Validation rules catch errors that compound silently. Required field checks, range validation, duplicate detection, and cross-validation (do line items sum to the total?) prevent weeks of bad data from accumulating before anyone notices.
- Cost depends on document quality. Born-digital PDFs cost $0.02-0.04 each to process. Scanned documents requiring vision extraction cost $0.50-1.00 each. Push vendors toward digital formats wherever possible.
- The daily Telegram summary turns data entry from a task you perform into a dashboard you glance at. Most mornings it is a green light. The mornings it is not, you know exactly what needs attention.
Related Resources
- How to Set Up OpenClaw the Right Way: 10 Steps — prerequisite installation and model selection
- How to Connect Google Sheets to OpenClaw — detailed OAuth setup for Sheets integration
- How to Connect Airtable to OpenClaw — API key setup and base configuration
- OpenClaw Heartbeat Scheduling: Configure Proactive Agent Behavior — tuning the morning summary interval and cost
- How to Use OpenClaw for Content Creation — another practical workflow using the same skill + cron architecture
SFAI Labs
