How to Build an Image to Text OCR Pipeline in Clay

Traditional optical character recognition (OCR) tools achieve high accuracy on clean, printed documents. However, Google Cloud Vision achieves 80% to 95% handwriting accuracy, whereas open-source Tesseract drops to 20% to 40% [Eklavvya OCR Handwriting Accuracy Study]. This discrepancy highlights where automated pipelines break down when reading raw physical assets, business cards, or scanned event sign-up sheets.

For outbound sales and growth operations teams, this error rate represents a major bottleneck. If a company receives handwritten lead forms from a trade show, using a low-quality OCR engine means manually correcting the majority of records. When scaled across multiple events, manual data entry ruins campaign timelines. Growth teams often try to bypass this by manually uploading screenshots or images to basic browser-based converters. These tools do not scale. They require manual drag-and-drop operations, lack automation capabilities, and expose business data to third-party consumer sites with weak privacy standards.

To solve this, modern revenue operations teams are transitioning to programmatic pipelines. These pipelines feed graphic assets, document scans, and system screenshots directly into relational data grids. Multimodal vision models now read handwritten, structured, and unstructured text in images, enabling automated extraction. By connecting these models to automated databases, organizations process batch image datasets, moving from raw assets to structured records. Clay acts as the enrichment workspace that coordinates these visual API transactions.

This guide shows how to build an automated folder-to-table GTM data pipeline. Rather than processing images individually in a web browser, we will orchestrate a system that detects new files, performs high-fidelity OCR, runs visual analysis, and delivers structured leads directly to your sales team.

Selecting the right API depends on document structure, handwriting frequency, and formatting requirements. For simple print documents, legacy OCR works well. For handwritten notes or complex layout structures, vision models are necessary.

Here is a comparison of the primary OCR APIs compatible with Clay workflows:

Google Cloud Vision provides high character recognition, especially for non-Latin characters and messy handwriting. It returns exact character coordinates, which is helpful if you need to know where text appears on a page.

PDF.co is built for document formatting, making it ideal for extracting tables, parsing invoices, and processing multi-page PDFs. It converts documents into structured tables, reducing the downstream parsing needed.

OpenAI's GPT-4o Vision handles visual reasoning. Rather than just recognizing characters, it interprets meaning. For example, if you upload a photo of a business card, GPT-4o can identify which text is the email address and which is the job title, even if the layout is non-standard. The trade-off is latency and token cost, which are higher than traditional OCR APIs.

Automated pipelines require a staging repository where files can be written programmatically and reviewed by team members.

Growth operations teams often store incoming documents in local directories or standard cloud storage repositories like Google Drive or Amazon S3. These storage options have limitations. Local storage isolates files on individual computers, preventing team collaboration and automation. Amazon S3 offers API access, but lacks a clean user interface for human verification and does not provide built-in document indexing. Google Drive supports file sharing, but its API rate limits can throttle high-volume batch runs, and its permission model makes it difficult to isolate automated agent accounts from sensitive corporate files.

Fastio solves these issues by providing shared workspaces designed for human-agent collaboration.

Fastio organizations run on a paid subscription model with a 14-day free trial that requires a credit card [Fastio Pricing]. Teams can choose from three plans: Starter at $29/mo, Business at $99/mo, or Growth at $299/mo. For details about these packages, visit the Fastio pricing directory.

When building a pipeline, you can isolate your automated agents in a dedicated workspace, keeping other corporate directories secure. The workspace keeps a complete, per-file version history. If an agent runs an incorrect update or overwrites a file, team members can restore prior versions, making concurrent work safe.

Additionally, Fastio supports ownership transfer. An agent can sign up free, construct the workspaces, build the sharing links, and configure the folders. When the configuration is complete, the agent generates a claim link to transfer ownership to a human manager. The agent retains admin access while the human user assumes control of billing and organization membership, simplifying developer-to-client handoffs.

Before sending images to Clay, you can extract structured text directly within Fastio. While standard search indices retrieve documents based on keywords, structured pipelines require typed fields.

Fastio's Metadata Views (which you can learn about on the document data extraction page) turn unstructured files into a queryable spreadsheet database.

Users describe the fields they want extracted in natural language. The AI designs a typed schema (supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time), scans the workspace, matches files, and populates the database. This works with PDFs, images, scanned pages, and handwritten notes.

You can configure a Metadata View to extract key fields before the data reaches Clay. For example, if your workspace receives event registration photos, you can configure the view with three columns: lead_name (Text), contact_email (Text), and registration_date (Date & Time). The built-in AI processes the images and populates these fields automatically. If you add a new column later, the view performs incremental extraction without reprocessing old files.

It is important to distinguish Metadata Views from Intelligence Mode. Intelligence Mode is the workspace's search and summarization layer, allowing users and agents to run semantic searches and ask questions with citations. Metadata Views are the structured extraction layer, formatting document details into a queryable spreadsheet.

Developers can interact with Metadata Views programmatically. The Fastio MCP server exposes Views as tools, allowing agents to create schemas, trigger extraction runs, and query results using a consolidated MCP toolset. The MCP server is accessible via Streamable HTTP at /mcp or legacy SSE at /sse. More information about agentic tooling is available in our guide on storage for agents.

Deploy persistent document extraction workspaces

Create shared workspaces with built-in Metadata Views to parse scanned documents and images automatically. Connect your automation pipelines using our MCP server and start your 14-day free trial.

Start 14-Day Trial

Once files are staged in Fastio, you can connect them to Clay for GTM enrichment. Clay does not store large binary files directly in table cells. Instead, it processes public URLs to analyze image content.

To feed images to Clay, you can generate branded shares in Fastio. These shares can be set to expire or remain durable, and you can manage per-recipient access grants individually. Because these shares are versioned, any updates to the source files are reflected instantly, ensuring Clay always accesses the current version.

To build the pipeline, follow these configuration steps: First, create a webhook in Clay to receive file events. When a new file is uploaded to your Fastio workspace, the system fires a webhook containing the share URL. Second, configure a column in your Clay table to store the incoming image URL. Third, add the OpenAI integration column. Search for the 'Analyze image with OpenAI/GPT' action. Configure the input to point to your image URL column and select GPT-4o as the model. Fourth, write a specific prompt for the vision model. To ensure the model returns structured text without explanation, use a system prompt like this:

{
  "prompt": "Extract the following fields from the image: business name, contact person, email, and phone number. Return the output as a flat JSON object with keys: business_name, contact_name, email, and phone. Do not include markdown formatting or extra explanation."
}

When Fastio fires a webhook, it sends a payload containing file details. A typical payload looks like this:

{
  "event": "file.created",
  "timestamp": "2026-07-22T04:19:18Z",
  "data": {
    "orgId": "org_98765432101234567890",
    "workspaceId": "ws_12345678901234567890",
    "fileId": "file_88888888888888888888",
    "name": "receipt_registration_04.png",
    "shareUrl": "https://fast.io/s/rec_55555555555555555555"
  }
}

By parsing this JSON payload in your middleware, you can retrieve the target fileId and trigger downstream enrichments.

If you prefer to bypass Clay's built-in OpenAI interface, you can write a serverless middleware function to coordinate the file download and extraction. The following Node.js code demonstrates how to read a file from Fastio, send it to the OpenAI API for analysis, and write the extracted data back to your database:

// Middleware to extract text from images using OpenAI Vision
import axios from 'axios';
export async function processImageInvoice(req, res) {
  const { fileId, workspaceId, orgId } = req.body;
  const fastioMcp = 'https://mcp.fast.io/mcp/key';
    const fastioAuth = { Authorization: 'Bearer ' + process.env.FASTIO_API_KEY };
  try {
    // 1. Retrieve the file metadata and download link from Fastio
    const fileMetadata = await fastio.files.getMetadata({ orgId, workspaceId, fileId });
    const downloadBuffer = await fastio.files.download({ orgId, workspaceId, fileId });
    // Convert binary image to base64
    const base64Image = downloadBuffer.toString('base64');
    const dataUrl = `data:${fileMetadata.mimeType};base64,${base64Image}`;
    // 2. Call OpenAI API with vision capabilities
    const oaiResponse = await axios.post(
      'https://api.openai.com/v1/chat/completions',
      {
        model: 'gpt-4o',
        messages: [
          {
            role: 'user',
            content: [
              { type: 'text', text: 'Extract invoice number, total amount, and date as JSON.' },
              { type: 'image_url', image_url: { url: dataUrl } }
            ]
          }
        ],
        response_format: { type: 'json_object' }
      },
      {
        headers: {
          Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );
    const extractedData = JSON.parse(oaiResponse.data.choices[0].message.content);
    return res.json({ success: true, data: extractedData });
  } catch (error) {
    console.error('Image analysis pipeline failed:', error);
    return res.status(500).json({ error: 'Failed to extract text from image' });
  }
}

This middleware isolates binary file handling, keeping your Clay tables clean and focused on text-based enrichment data.

Processing thousands of images introduces challenges around API rate limits, file size constraints, and error handling. Batch image processing scales to thousands of rows in Clay, but it requires careful staging and configuration.

When running batch enrichments, do not load files directly from local storage. Instead, staging databases or Google Sheets can be used as intermediate queues. However, staging databases require custom API builds, and Google Sheets can suffer from slow execution speeds and cell size limitations when storing long JSON outputs. Staging files in Fastio workspaces provides a cleaner path, as the workspace acts as an organized file repository.

To optimize high-volume runs, implement the following best practices:

First, implement rate limit handling. Vision models are resource-intensive, and API providers enforce strict rate limits on request volume. Configure your middleware with exponential backoff retries, pausing requests when receiving rate limit status codes.

Second, manage file ingestion limits. High-resolution images slow down processing times and consume unnecessary bandwidth. Scale high-resolution images down to standard dimensions before uploading, which preserves OCR readability while reducing token consumption. Fastio supports chunked uploads for large assets, ensuring that batch transfers are completed without network timeout failures.

Third, audit changes using version history. When automated agents write data back to your workspace, mistakes can happen. Every file in Fastio keeps a full version history, ensuring that prior versions can be restored. The append-only audit log provides an immutable record of all agent and human modifications, maintaining a clear chain of custody.

No automated vision model is always correct. To prevent invalid contact records or incorrect billing amounts from entering your CRM, you must establish a manual review queue.

Fastio's Workflow Engine (accessible on our workflows page) allows you to build custom validation sequences. You can construct workflows in plain language as a directed acyclic graph (DAG) of steps. The engine supports five trigger kinds: manual, scheduled, event, webhook, and AI-driven.

To configure a review pipeline, set up an AI-driven step to evaluate the extraction confidence score. If the vision model's confidence rating is below your target threshold, configure the workflow to flag the record. Instead of writing data directly to production tables, the system routes the file and the extracted data to a human teammate's obligation inbox.

The review process follows a structured four-step flow: Submit, Review, Approve or Reject, and Complete. The human reviewer opens the file preview inside Fastio, reviews the extracted spreadsheet columns side-by-side, and approves or rejects the record. Fastio's inline preview engine supports PDFs, images, PSDs, and CAD drawings natively, allowing reviewers to verify files without downloading them.

An immutable approval audit trail records the reviewer's identity, timestamps, and comments, keeping the process transparent. Once approved, the record is automatically written to your production databases or synced to your CRM, ensuring high data hygiene.

By combining automated Metadata Views, Clay enrichments, and human-in-the-loop validation, teams can build highly accurate image-to-text pipelines that scale without sacrificing quality.