A Technical Guide to the Clay Chrome Extension for Scraping Leads

Only 28% of a sales representative's workweek is spent on selling activities, with the remaining 72% consumed by manual prospect research, data cleaning, and CRM administrative entry [Salesforce 2026 State of Sales Report]. This administrative overhead prevents sales development representatives (SDRs) from focusing on direct client outreach and pipeline growth. When sales teams rely on manual copy-and-paste processes to build outreach lists from online directories, they introduce errors, format inconsistencies, and stale records that decrease email deliverability and conversion rates.

The Clay Chrome Extension is a web companion tool that enables users to auto-detect lists and build custom scraping recipes to import data directly into Clay tables. By integrating data collection directly into the browser, the extension bypasses the need for manual copy-pasting. It allows growth teams to map repeating lists, extract data from complex document object models (DOMs), and send structured records straight into automated enrichment tables.

To scrape effectively, teams must distinguish between the two primary extensions offered. The main scraping extension, Clay for Chrome, is designed for web scraping and structured extraction of lists or attributes. The clip to clay extension is a related bookmarking tool used to quickly save or clip entire pages, unstructured text segments, or bookmarks into tables for subsequent processing. Understanding this distinction ensures that teams configure the correct tool for structured outbound sales list building.

Setting up the lead extraction workflow begins with the installation of the web extension. To install the tool, open the Google Chrome Web Store and search for the official extension, clay for chrome. Click the installation button to add the extension to the browser. Once installed, pin the extension to the browser toolbar for quick access during research sessions.

After installation, click the extension icon to authenticate. The extension directly links browser sessions to Clay table workspaces. This live link uses active session cookies to securely map the browser interface to the user's workspace tables. If the session expires, the extension will prompt the user to re-authenticate by logging into the main platform in another browser tab.

Once authenticated, the extension interface displays the active workspace, letting researchers select the specific table where they want to append incoming leads. If a matching table does not exist, users can initialize a new target table directly from the browser popup. This ensures that any data scraped from the active webpage immediately transfers to the target destination without intermediate file exports.

When navigating to a directory page, the browser extension attempts to automatically identify repeating structures. If the layout is standard, such as a tabular directory or a grid of cards, the auto-detect feature presents a preview of the columns. The researcher can review the columns, map the fields, and click the button to add the records to their table.

However, many target websites employ custom CSS classes, shadow DOMs, or nested wrappers that block standard auto-detect scrapers. To overcome this limitation, developers must build clay custom scraping recipes. A custom recipe allows users to manually map specific elements on the page, creating a reusable template for identical layouts across the target domain.

Creating a custom recipe involves a structured selector mapping workflow:

• Initialize the Recipe: Open the extension on the target directory and select the option to create a new custom recipe. Provide a descriptive name based on the target website.
• Define the URL Pattern: Specify the matching URL structure, such as example.com/directory/*. This ensures that the recipe loads automatically whenever a researcher views a page that matches this pattern.
• Select the List Container: Click the repeating container wrapper. The scraper requires you to select at least two similar container items on the page. This teaches the selector engine the recurring HTML structure.
• Map Individual Attributes: Within each container, click on specific elements and assign them to database columns. You must map these elements to specific attribute types:
  • Text Attribute: Use this for plain-text fields like names, descriptions, or company sectors.
  • Link Attribute: Use this for hyperlinks, ensuring the scraper extracts the raw URL rather than the anchor text. This is critical for capturing company websites and social profiles.
  • Image Attribute: Use this to scrape logos, avatar URLs, or other visual assets.
• Configure Pagination: If the directory spans multiple pages, define the pagination URL pattern. The extension uses URL variables to loop through paginated results, appending them to the same table.
• Test and Save: Verify the preview grid in the extension popup to ensure that column names align with the extracted data. Save the recipe to make it available for future scraping runs on the matching domain.

Outbound researchers often encounter sites that load content dynamically. Modern directories load rows as the user scrolls or click a show more button. To scrape these sites, the Clay for Chrome extension allows researchers to configure scroll triggers within the custom recipe. When configuring the list container, researchers can set a scroll delay, instructing the extension to pause for a brief delay to allow AJAX requests to resolve and populate the DOM before extracting the mapped attributes.

Another common edge case is iframe nesting. When data is embedded within an inline frame, standard browser selectors cannot access the inner DOM tree. In these scenarios, researchers must inspect the frame source URL, open the source document in a new tab, and apply the custom scraping recipe directly to the parent document. This approach guarantees that selectors remain stable and do not return null values.

After compiling lists of scraped prospects using the Clay Chrome Extension, teams need to store, organize, and version these files. While local folders or generic cloud drives (like Google Drive or OneDrive) are common starting points, they lack automated indexing, detailed audit logs, and agent-friendly programming interfaces. For teams employing AI agents for outbound research, raw object storage solutions (like AWS S3) require building complex custom retrieval pipelines.

Fastio shared workspaces function as the persistent storage and shareable workspace layer around Clay, not as a built-in Clay feature. Researchers can export their scraped directories as structured CSV or JSON files and import them directly into a Fastio workspace. Fastio organizes these datasets with granular permissions across the organization, workspace, folder, or file level.

Because outbound lists are constantly updated by multiple team members and automated agents, keeping data consistent is a common challenge. Fastio resolves this by maintaining a complete per-file version history. When an agent or human updates a lead CSV, the system saves the changes as a new version. Teams can preview historical states or restore prior versions at any time.

Developers and AI agents can interact with these stored lead lists using the Fastio Model Context Protocol (MCP) server. Fastio exposes its MCP server via Streamable HTTP at https://mcp.fast.io/mcp and legacy SSE at https://mcp.fast.io/sse (documented at fast.io/llms.txt and the Fastio Developer Portal). This allows agents running on different systems to read and write lead files directly. When a new lead list is uploaded, enabling Intelligence Mode on the workspace automatically indexes the file. Team members can run RAG chat queries over the data, retrieving specific contacts with precise citations to the source file and line numbers.

The following Python script shows how an outreach agent can confirm version history on a scraped lead list and download the current file from a Fastio workspace:

import os
import requests

api_key = os.getenv("FASTIO_API_KEY")
workspace_id = "1234567890123456789"
node_id = "1234567890123456789"

headers = {
    "Authorization": f"Bearer {api_key}"
}

# Confirm version history on the scraped lead list
versions_url = f"https://api.fast.io/current/workspace/{workspace_id}/storage/{node_id}/versions/"
versions_response = requests.get(versions_url, headers=headers)
if versions_response.status_code == 200:
    print("Version history retrieved.")

# Download the current lead list
read_url = f"https://api.fast.io/current/workspace/{workspace_id}/storage/{node_id}/read/"
read_response = requests.get(read_url, headers=headers)
if read_response.status_code == 200:
    print("Lead list downloaded.")

Store your Clay Chrome Extension leads in Fastio

A shared workspace with an MCP-ready endpoint to persist, search, and version your Clay scraping exports. Starts with a 14-day free trial.

Start 14-Day Trial

Importing raw scraped lists into Fastio workspaces is only the first step in the data pipeline. To make the data useful, sales operations teams can configure Metadata Views. Unlike rigid templates or optical character recognition rules, Metadata Views allow users to define fields (like email, company name, industry, and employee count) in natural language. The system automatically reads the uploaded CSVs or scanned PDF documents, designs a typed schema, and extracts the records into a queryable data grid. This grid can be sorted and filtered by metadata values (such as querying for email addresses containing specific domains or filtering company sizes) without manual entry.

Once those views are in place, Ripley, the built-in RAG agent, can answer questions over the uploaded CSVs and PDFs with citations back to the source list. Sales managers can review who uploaded or updated a file in the workspace audit log. Teams that need a spreadsheet of extracted fields can export a Metadata View and hand it to account executives or import it into a CRM.

After the leads have been compiled, enriched, and structured, the workflow often requires handoff to account executives or external clients. Fastio accommodates this with its ownership transfer feature. An AI agent or an operations builder can create the workspace, upload the leads, configure the Metadata Views, and then initiate an ownership transfer. This process generates a secure link that allows the human recipient to assume full control of the organization. The initiating builder can retain admin permissions for ongoing maintenance if needed.

To share specific segments of lead lists securely with external partners, sales reps can create branded shares (Send, Receive, or Exchange workflows). These shares support password protection and custom client branding. You can set them to expire after a certain period or configure them for per-recipient access, letting you grant or revoke download permissions individually. This ensures that outbound sales data remains protected.

For teams executing these workflows, Fastio operates on a credit-based subscription model. Organizations can sign up for the Starter plan at $29 monthly, the Business plan at $99 monthly, or the Growth plan at $299 monthly. Each plan includes a 14-day free trial that requires a credit card, ensuring teams can test the intelligence features and MCP server prior to starting a billing cycle.