Getting Started with Clay.com: GTM Platform Pricing and Features

On March 11, 2026, Clay overhauled its pricing model to introduce a dual-credit system that separates Data Credits from Actions, which raised the minimum starting self-serve tier to $185/month [Clay Pricing]. For outbound sales teams and growth engineers, this billing shift has highlighted a major challenge in Go-to-Market (GTM) operations. While B2B list building and enrichment are essential for pipeline growth, the unpredictable costs of running multi-provider data waterfalls can quickly escalate beyond a team's monthly budget.

Clay functions as a data orchestrator rather than a traditional contact database. Instead of maintaining its own data registry, Clay acts as a meta-provider, querying over 50 third-party databases in real time to locate B2B emails, mobile phone numbers, and corporate signals. This aggregation is powerful, but it comes with a high platform markup and a complex consumption structure.

A recent 2026 sales development survey by Lindy shows that while 85% of GTM teams praise Clay's data enrichment capabilities, more than half struggle to accurately forecast their monthly billing because of the platform's multi-step credit structure [Lindy Clay Review]. Outbound teams must balance the cost of raw data lookup with the platform orchestration fees that power their workflows.

To understand your GTM budget, you must analyze how Clay separates platform labor from data acquisition. The March 2026 billing update introduced a clear distinction between Data Credits and Actions, replacing the older legacy plans.

Data Credits

Data Credits are used exclusively to purchase contact details and firmographics from Clay's data marketplace. When you query an external vendor to find a mobile phone number or verify an email address, you pay in Data Credits [Clay Pricing]. Under the 2026 model, Clay operates on a pay-for-success basis for these credits. If a database search returns empty or fails to find the target lead, you are not billed any Data Credits. The cost per search varies by provider, with standard email lookups costing around 2 credits, while verified mobile dials can consume between 5 and 25 credits.

Actions

Actions measure the platform work required to run your tables and automate your GTM workflows. Every enrichment step, AI model call, database write, CRM push, or table export consumes Actions. Unlike Data Credits, Actions are consumed for every operation executed, regardless of whether a lead lookup finds data or returns empty. This means platform labor is metered continuously, even during failed search attempts.

Clay Subscription Tiers

The current self-serve pricing model is divided into three options, all supporting unlimited users to encourage team collaboration:

• Free Plan: Includes 100 Data Credits and 500 Actions per month [Clay Free Plan]. No credit card is required. It is designed for basic testing and learning the interface but is not suitable for running active outbound campaigns.
• Launch Plan: Costs $185/month. Includes 2,500 Data Credits and 15,000 Actions per month [Clay Pricing]. This plan is designed for early-stage teams getting started with structured outbound sequences.
• Growth Plan: Costs $495/month. Includes 6,000 Data Credits and 40,000 Actions per month [Clay Tiers]. This tier adds CRM integrations for Salesforce and HubSpot, HTTP APIs, webhooks, and advanced prospecting signals.
• Enterprise Plan: Offers custom pricing with tailored credit allotments, custom data integrations, and dedicated account support for large GTM organizations.

Waterfall enrichment is a sequential lookup strategy that checks multiple data providers one by one. If the first database fails to find a lead's email, the workflow automatically queries the second, then the third, until it finds a match. Once a provider succeeds, the waterfall stops, ensuring you only pay Data Credits for the successful match.

While this sequential logic is cost-effective for Data Credits, it can lead to unexpected billing through Action consumption. Because Actions measure platform execution, Clay charges one Action for every single provider checked in a row, whether that check succeeds or fails.

To see how this affects your GTM billing, consider a list of 10,000 prospects run through a four-tier waterfall:

• Step 1 (Provider A): Clay runs all 10,000 rows. It succeeds for 2,000 rows and fails for 8,000 rows. This step consumes 10,000 Actions and Data Credits for the 2,000 matches.
• Step 2 (Provider B): The system runs the remaining 8,000 rows. It finds matches for 2,000 rows and fails for 6,000 rows. This step consumes 8,000 Actions and Data Credits for the 2,000 matches.
• Step 3 (Provider C): The system runs the remaining 6,000 rows. It finds matches for 2,000 rows and fails for 4,000 rows. This step consumes 6,000 Actions and Data Credits for the 2,000 matches.
• Step 4 (Provider D): The system runs the remaining 4,000 rows. It finds matches for 1,000 rows and fails for 3,000 rows. This step consumes 4,000 Actions and Data Credits for the 1,000 matches.

In this scenario, the GTM team successfully enriches 7,000 contact records. They are billed Data Credits only for those 7,000 successful matches. However, the table has executed 28,000 individual operations. This single run consumes 28,000 Actions, immediately blowing past the Launch plan's monthly allocation of 15,000 Actions [Clay Pricing]. The team is forced to pay Action overage fees or upgrade to the $495/month Growth plan, even though their successful enrichment matches were much lower.

This Action billing model is a common gap in commercial reviews. Outbound engineers who build deep waterfalls containing six or seven providers often find themselves paying steep overage fees because they did not account for the cumulative cost of failed lookups.

Managing your GTM budget requires setting up structural checks within your tables to limit unnecessary operations. You can optimize your workspace using four primary cost-control methods.

Filter Lists Before Running Enrichments

Never import a raw list and run a waterfall across every row. Use filters to clean the data first. If a prospect's record already contains a company email address, configure your waterfall columns to skip that row entirely. This simple validation check prevents you from spending Actions and Data Credits on information you already own.

Bring Your Own API Keys (BYOK)

If you maintain independent subscriptions with B2B data providers like Apollo or Hunter, you can input your own API keys in Clay. This bypasses Clay's marketplace markup, saving between 50% and 80% on Data Credits. However, keep in mind that Clay still charges platform Actions for running the steps in the table, even when using your own keys.

Apply Conditional Enrichment Logic

Configure your tables to run enrichments only when specific criteria are met. For example, you can set a rule to only run a contact lookup if the company is in your target industry or has recently raised capital. This targets your budget toward high-intent accounts.

Test Workflows in Small Batches

Before running a table with 20,000 leads, duplicate the workflow and run it on a sample of 10 to 20 rows. Review the results to verify that your sequential waterfall triggers and stops correctly. This test run lets you catch formula errors and inefficient sequences before they consume your monthly credit quota.

Store and organize your clay.com lead exports in Fastio

Maintain a persistent, shared workspace for your clay.com prospecting lists. Use Metadata Views to extract structured lead databases from raw files, complete with version history and collaborative editing. Starts with a 14-day free trial.

Start 14-Day Trial

While Clay is a powerful engine for GTM lead enrichment, it is designed for real-time list construction rather than persistent data storage or long-term file management. As outbound campaigns grow, teams require a secure workspace to collaborate on lead databases, store historic campaign files, and organize contract documentation. This is where Fastio serves as an ideal persistent storage and collaboration layer around Clay.

Instead of leaving enriched data in temporary spreadsheets, GTM teams export their Clay lists and store the CSV outputs in a shared workspace on Fastio. This central repository organizes GTM files in one location, allowing sales reps and outbound agents to work on the same materials. Fastio provides granular permissions across organizations, workspaces, folders, and files, backed by an append-only audit log. Every upload keeps a detailed version history, meaning that concurrent edits from human reps and developer agents are fully auditable.

Structure Lead Lists with Metadata Views

When GTM teams receive unstructured files like scanned notes, pitch sheets, or raw prospect profiles, they can use Metadata Views to structure the information without manual data entry. Metadata Views turn documents into a live, queryable database. Users describe the fields they want extracted in natural language, and Fastio's AI designs a typed schema supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time formats. The system matches files in the workspace and extracts the records into a filterable grid. You can find more detail at the Metadata Views product page.

Collaborative Workspace Tools

Inside a Fastio workspace, team members can collaborate in real time. Fastio Notes brings co-editing to every workspace with multiplayer cursors, allowing human managers and AI agents to co-edit sales scripts and prospecting copy. When sharing enriched lists with external agencies or clients, teams use branded shares (Send, Receive, and Exchange) with expiring access and download controls. Enable Intelligence Mode to index all documents for semantic search and citation-backed Q&A, allowing reps to query lead summaries using the built-in AI.

Developer Workflows and the Fastio API

For developer-first teams, Fastio offers a streamlined alternative to platform markups. By writing custom scraping agents that query data providers directly via their APIs, developers can dump raw JSON or CSV outputs directly into a Fastio workspace. Fastio exposes a Model Context Protocol (MCP) server with Streamable HTTP at https://mcp.fast.io/mcp and legacy SSE at https://mcp.fast.io/sse, allowing developer scripts to upload files and trigger metadata extraction.

Fastio subscriptions are usage-based, starting with a 14-day free trial per organization (credit card required) [Fastio Pricing]. Paid plans include the Starter plan at $29/month, the Business plan at $99/month, and the Growth plan at $299/month. External developers can build out workspaces for a client, test the integration, and then transfer organization ownership to the client via a secure claim link.

Below is an example of a Python script that runs a scraper, saves the lead details, and uploads them to a Fastio workspace with POST https://api.fast.io/current/upload/.

import json
import requests

FASTIO_API_KEY = "your_key"
FASTIO_WORKSPACE_ID = "1234567890123456789"

def save_and_upload_leads(domain, lead_data):
    #-- Prepare raw JSON file representing lead data
    filename = f"leads_{domain}.json"
    with open(filename, "w") as f:
        json.dump(lead_data, f, indent=4)

#-- Fastio pricing: Starter $29/mo, Business $99/mo, Growth $299/mo
    #-- Includes a 14-day trial per organization (credit card required)
    upload_url = "https://api.fast.io/current/upload/"
    headers = {
        "Authorization": f"Bearer {FASTIO_API_KEY}"
    }

with open(filename, "rb") as f:
        file_bytes = f.read()
        response = requests.post(
            upload_url,
            headers=headers,
            files={"chunk": (filename, file_bytes, "application/json")},
            data={
                "name": filename,
                "size": str(len(file_bytes)),
                "action": "create",
                "instance_id": FASTIO_WORKSPACE_ID,
                "folder_id": "root",
            },
        )

if response.status_code == 201:
        print(f"Successfully uploaded {filename} to Fastio.")
        #-- Trigger further processing using Fastio MCP Streamable HTTP at https://mcp.fast.io/mcp
        return response.json()
    else:
        print("Upload failed:", response.text)
        return None

sample_leads = {
    "company": "Fastio",
    "industry": "Cloud Storage",
    "contacts": [
        {"name": "Jane Doe", "role": "GTM Lead", "email": "jane@fast.io"}
    ]
}
save_and_upload_leads("fast.io", sample_leads)

Selecting the right B2B lead enrichment approach depends on your GTM scale, budget, and development capacity. While Clay is an excellent tool for complex, multi-provider prospecting tables, teams must actively manage their workflows to prevent runaway credit costs.

When to Use Clay

Clay is the leading choice for growth teams that require real-time, multi-source lead research without writing custom integration code. Its spreadsheet-as-code interface allows RevOps teams to configure complex sequences, verify corporate email addresses, and pull data from dozens of providers within a single workspace. If you have the budget to support the $185/month Launch or $495/month Growth subscriptions, plus data credit and action overage fees, Clay provides exceptional speed for GTM list preparation [Clay Pricing].

When to Build a Custom Workspace Pipeline

For developer-first teams, high-volume outreach agencies, and startups seeking to minimize GTM platforms fees, building a custom pipeline is a cost-effective alternative. By writing scraper scripts and query engines that call data provider APIs directly, you pay raw data rates and completely bypass Clay's platform Action markups. Dumping these raw outputs into a persistent, shared Fastio workspace provides a central collaborative canvas.

Using Fastio's Metadata Views, non-technical sales representatives can structure raw files and query B2B lead records within an interactive grid. Sales teams get the collaborative benefit of shared workspaces and RAG-grounded search without paying high GTM orchestration markup fees.