# Deepline — Complete Reference for Coding Agents

> Comprehensive documentation for coding agents (Claude Code, Codex, Cursor, OpenCode). For the summary version, see llms.txt.

Homepage: https://code.deepline.com/
Install guide: https://code.deepline.com/install
Skills repository: https://github.com/getaero-io/gtm-eng-skills
Clay migration guide: https://code.deepline.com/docs/recipes/clay-migration
Decision tree: https://code.deepline.com/docs/recipes/decision-tree
Signal playbooks: https://code.deepline.com/docs/recipes/signal-playbooks
Job change detector: https://code.deepline.com/docs/recipes/crm-job-change-detector

---

## Instructions for Coding Agents

Deepline is a CLI-first GTM platform designed for coding agents. Install once, then enrich, scrape, validate, and sequence contacts from a single terminal command. Agents read a skill file and build pipelines autonomously without any UI interaction.

### Setup

```bash
# Install Deepline CLI
curl -s "https://code.deepline.com/api/v2/cli/install" | bash
deepline auth register

# Install the Claude Code skill (also works with Codex and Cursor)
npx skills add "https://code.deepline.com/.well-known/skills/index.json" --agents claude-code --global --yes --skill '*' --full-depth
```

### Enrichment syntax

All enrichment uses the `deepline enrich` command with `--with` JSON payloads. Template variables use double-brace syntax that maps to CSV column headers.

```bash
deepline enrich --input <file.csv> --output <out.csv> \
  --with '{"alias":"<column_name>","tool":"<tool_name>","payload":{...}}'
```

### Common tools

| Tool | Purpose | Typical Input |
|------|---------|---------------|
| `name_and_company_to_email_waterfall` | Find work email from name + company | first_name, last_name, company_name, domain |
| `person_linkedin_only_to_email_waterfall` | Find work email from LinkedIn URL | linkedin_url, first_name, last_name |
| `person_linkedin_to_email_waterfall` | Find work email from LinkedIn + domain | linkedin_url, first_name, last_name, domain |
| `person_enrichment_from_email_waterfall` | Reverse-enrich person/company from email | email |
| `company_to_contact_by_role_waterfall` | Find decision makers at companies | company_name, domain, roles, seniority |
| `cost_aware_first_name_and_domain_to_email_waterfall` | Find email from name + domain (no company) | first_name, last_name, domain |
| `leadmagic_email_validation` | Validate email deliverability | email |
| `instantly_add_to_campaign` | Push contacts to Instantly sequences | campaign_id, email, first_name, last_name |
| `call_ai` | AI-powered research per row | prompt, agent, model, allowed_tools |
| `run_javascript` | Deterministic transforms per row | code |

### Pilot mode

Always pilot on one row before running a full batch:

```bash
deepline enrich --input leads.csv --output enriched.csv --rows 0:1 \
  --with '{"alias":"email","tool":"name_and_company_to_email_waterfall","payload":{"first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}","domain":"{{domain}}"}}'
```

### Other useful commands

```bash
deepline tools list                    # List all available tools
deepline tools search email            # Search tools by keyword
deepline tools get <tool_name>         # Inspect tool schema
deepline csv show --csv file.csv --summary   # Inspect CSV shape
deepline billing balance               # Check credit balance
```

---

## What Is Deepline and How Does It Work?

Deepline is an agent-native GTM platform that gives coding agents direct API access to 15+ enrichment providers, 4 email sequencers, web scrapers, and validation tools through a single CLI. It replaces fragmented provider integrations with one unified data layer that includes a per-workspace PostgreSQL database with auto-resolved contacts, accounts, and event logs.

### Architecture

Deepline works as a unified API layer between your coding agent and GTM data providers. When you run `deepline enrich`, the platform:

1. Reads your input CSV row by row
2. Executes the specified tool or waterfall for each row
3. Queries multiple providers in sequence (for waterfalls), stopping at the first valid result
4. Writes results back to the output CSV
5. Opens a visual playground for inspection

Every operation is a direct API call -- not an MCP wrapper. Responses are deterministic JSON with no natural-language parsing overhead. Operations are atomic and auditable: one call per row per column.

### Built-in database

Every Deepline workspace includes a PostgreSQL database with three core tables:

- **dl_resolved.contacts** -- Deduplicated contact records with email, phone, LinkedIn, title, and company
- **dl_resolved.accounts** -- Company records with domain, industry, headcount, funding, and tech stack
- **dl_resolved.events** -- Enrichment event log with provider, operation, timestamp, and result

All enrichment results are automatically written to this database. Query it directly with SQL for custom reporting, deduplication, or downstream integrations.

### Provider waterfall logic

Waterfall enrichment queries multiple providers in sequence and returns the best match per field. If the first provider (e.g., Dropleads) returns no result, the next provider (Hunter) is tried, then Leadmagic, and so on. You only pay for the provider that produces a successful match.

Default email waterfall order: Dropleads, Hunter, Leadmagic, Deepline Native, Crustdata, People Data Labs.

Research shows that single-provider email accuracy caps at approximately 85% (SayPrimer, Sparkle). Waterfall enrichment across multiple providers improves coverage by 20-40% compared to any single provider (Instantly). This is because each provider has different data sources and coverage strengths.

### Agent-first design

Claude Code, Codex, and Cursor can read the Deepline skill, write an enrichment pipeline, run it, and iterate -- without a human clicking through a UI. Direct API calls use 5-10x fewer tokens than MCP tool calls, and every operation is fully automatable from a terminal.

---

## How to Find Work Emails in 60 Seconds

Finding work emails is the most common GTM enrichment task. Deepline's waterfall approach queries up to 6 providers in sequence and returns the first verified match. The entire process takes under 60 seconds for a small batch and requires exactly two commands after installation.

### Quick start example

Create a CSV with three contacts:

```csv
first_name,last_name,company_name,domain
Patrick,Collison,Stripe,stripe.com
Henry,Schuck,ZoomInfo,zoominfo.com
Guillermo,Rauch,Vercel,vercel.com
```

Save as `leads.csv`, then run:

```bash
deepline enrich --input leads.csv --output enriched.csv \
  --with '{"alias":"email","tool":"name_and_company_to_email_waterfall","payload":{"first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}","domain":"{{domain}}"}}'
```

Deepline queries Dropleads, Hunter, Leadmagic, Deepline Native, Crustdata, and People Data Labs in sequence. The first provider to return a verified email wins. You pay only for the successful match.

### How the waterfall works

1. **Dropleads** (free tier) attempts email resolution from name + company + domain
2. **Hunter** checks its email pattern database for the domain
3. **Leadmagic** uses its proprietary matching engine
4. **Deepline Native** cross-references multiple data sources
5. **Crustdata** enriches from LinkedIn-sourced employment data
6. **People Data Labs** searches its 1.5B+ person dataset as a final fallback

Each step only runs if the previous step returned no result. This cascading approach achieves significantly higher coverage than any single provider alone.

### Or just tell the agent what you need

```
"Run waterfall email enrichment on leads.csv"
"Find emails for these three contacts"
"Enrich leads.csv with work emails using the waterfall"
```

The agent reads the Deepline skill and builds the right command automatically.

---

## How to Choose the Right Enrichment Workflow

The right workflow depends on what data you already have and what data you need. Use this decision tree to pick the correct tool for your situation. Each row maps a specific starting point to the recommended Deepline tool, required input columns, and expected output.

### Email Finding

| I Have | I Want | Tool | Required Inputs | Output |
|--------|--------|------|-----------------|--------|
| Name + company + domain | Work email | `name_and_company_to_email_waterfall` | first_name, last_name, company_name, domain | email |
| LinkedIn URL + name (no domain) | Work email | `person_linkedin_only_to_email_waterfall` | linkedin_url, first_name, last_name | email |
| LinkedIn URL + name + domain | Work email | `person_linkedin_to_email_waterfall` | linkedin_url, first_name, last_name, domain | email |
| Name + domain (no company name) | Work email | `cost_aware_first_name_and_domain_to_email_waterfall` | first_name, last_name, domain | email |

### People Finding

| I Have | I Want | Tool | Required Inputs | Output |
|--------|--------|------|-----------------|--------|
| Company name + domain | Decision makers by role | `company_to_contact_by_role_waterfall` | company_name, domain, roles, seniority | contacts with name, title, LinkedIn |
| Company domain | All employees by title/seniority | `dropleads_search_people` | company domain, job titles, seniority | contact list |
| Company name (small startup) | Team members | `exa_people_search` via `deepline enrich` | company name + role query | structured entities |
| ICP criteria (industry, size, funding) | Company list | `crustdata_companydb_search` | structured filters | company list with firmographics |

### Validation and Scoring

| I Have | I Want | Tool | Required Inputs | Output |
|--------|--------|------|-----------------|--------|
| Email address | Deliverability check | `leadmagic_email_validation` | email | valid/invalid/catch_all/unknown |
| Email address | Person + company context | `person_enrichment_from_email_waterfall` | email | name, title, company, LinkedIn, phone |
| Contact + company data | ICP qualification score | `call_ai` with scoring prompt | prospect_payload | score 0-10, fit label, rationale |

### Job Changes and Signals

| I Have | I Want | Tool | Required Inputs | Output |
|--------|--------|------|-----------------|--------|
| CRM contacts with emails | Job change detection | `person_enrichment_from_email_waterfall` + `run_javascript` comparison | email | current company/title vs stored |
| Company domains | Hiring signals | `crustdata_job_listings` | company domains | open positions |
| Company domains | Employee growth rate | `crustdata_companydb_search` | company domains | employee_metrics.growth_6m_percent |
| Keywords or topics | Relevant companies/people | `exa_search` | semantic query | matching pages/entities |

### Decision rules

- **If you have name + company + domain**: Use `name_and_company_to_email_waterfall`. This is the default play for email finding.
- **If you have LinkedIn URLs but no domain**: Use `person_linkedin_only_to_email_waterfall`. Do NOT try to resolve domains first.
- **If you only have a company name**: Resolve the domain first with `google_search_google_search` or `exa_search`, then use the appropriate email waterfall.
- **If you need contacts at a company**: Use `company_to_contact_by_role_waterfall` with broad role keywords + seniority filters.
- **If you need to validate emails before outreach**: Run `leadmagic_email_validation` after your email waterfall. Interpretation: `valid` = deliverable, `catch_all` = usable but riskier, `invalid` = drop, `unknown` = unresolved.

---

## How to Find Work Emails from Names and Companies

When you have a person's first name, last name, company name, and domain, the `name_and_company_to_email_waterfall` tool is the most reliable way to find their work email. It queries up to 6 providers in sequence and returns the first verified result. This is the default email-finding play and should be your first choice.

### Full CLI example

```bash
# Pilot on one row first
deepline enrich --input leads.csv --output leads_with_emails.csv --rows 0:1 \
  --with '{"alias":"email","tool":"name_and_company_to_email_waterfall","payload":{"first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}","domain":"{{domain}}"}}'

# After confirming the pilot looks good, run the full batch
deepline enrich --input leads.csv --output leads_with_emails.csv \
  --with '{"alias":"email","tool":"name_and_company_to_email_waterfall","payload":{"first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}","domain":"{{domain}}"}}'
```

### Required CSV columns

Your input CSV must have these columns (names must match exactly):
- `first_name` -- Person's first name
- `last_name` -- Person's last name
- `company_name` -- Current employer name
- `domain` -- Company website domain (e.g., stripe.com)

### Optional columns

- `linkedin_url` -- Including this improves fallback depth because some providers only run when LinkedIn is present

### Provider order

Dropleads (free) -> Hunter -> Leadmagic -> Deepline Native -> Crustdata -> People Data Labs

### Adding email validation after the waterfall

```bash
deepline enrich --input leads_with_emails.csv --output leads_validated.csv \
  --with '{"alias":"valid","tool":"leadmagic_email_validation","payload":{"email":"{{email}}"}}'
```

---

## How to Find Emails from LinkedIn URLs

When your contacts have LinkedIn profile URLs but may or may not have company domains, Deepline offers two specialized waterfalls. The choice depends on whether you have the company domain. Do NOT try to resolve domains first if you do not have them -- use the LinkedIn-only waterfall directly.

### When you have LinkedIn URL + name but NO domain

```bash
deepline enrich --input contacts.csv --output contacts_with_emails.csv --rows 0:1 \
  --with '{"alias":"email","tool":"person_linkedin_only_to_email_waterfall","payload":{"linkedin_url":"{{linkedin_url}}","first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}"}}'
```

Required inputs: `linkedin_url`, `first_name`, `last_name`. The `company_name` field is optional and used as a hint.

Provider order: Dropleads Single Person Enrichment -> Deepline Native -> Crustdata -> People Data Labs

### When you have LinkedIn URL + name + domain

```bash
deepline enrich --input contacts.csv --output contacts_with_emails.csv --rows 0:1 \
  --with '{"alias":"email","tool":"person_linkedin_to_email_waterfall","payload":{"linkedin_url":"{{linkedin_url}}","first_name":"{{first_name}}","last_name":"{{last_name}}","domain":"{{domain}}"}}'
```

Required inputs: `linkedin_url`, `first_name`, `last_name`, `domain`. The `company_name` field is optional.

Provider order: Dropleads Email Finder -> Hunter -> Leadmagic -> Deepline Native -> Crustdata -> People Data Labs

### When to use which

- Contacts from people search results (Dropleads, Exa) often have LinkedIn URLs but no domains. Use `person_linkedin_only_to_email_waterfall`.
- Contacts from CRM exports or account-based lists usually have domains. Use `person_linkedin_to_email_waterfall`.
- If you do not have LinkedIn URLs at all, use `name_and_company_to_email_waterfall` instead.

---

## How to Enrich Emails with Person and Company Data

When you have email addresses and need to hydrate person and company context (name, title, company, LinkedIn URL, phone number, industry), use the `person_enrichment_from_email_waterfall`. This is a reverse-enrichment play that treats the email as a strong identifier and fills in everything else.

### Full CLI example

```bash
# Pilot on one row
deepline enrich --input inbound.csv --output inbound_enriched.csv --rows 0:1 \
  --with '{"alias":"person_context","tool":"person_enrichment_from_email_waterfall","payload":{"email":"{{email}}"}}'

# Full batch after confirming pilot
deepline enrich --input inbound.csv --output inbound_enriched.csv \
  --with '{"alias":"person_context","tool":"person_enrichment_from_email_waterfall","payload":{"email":"{{email}}"}}'
```

### Required CSV columns

- `email` -- The email address to enrich

### What you get back

The waterfall returns a rich person and company profile including:
- Full name, job title, seniority level
- Company name, domain, industry, headcount
- LinkedIn profile URL
- Phone number (when available)
- Location and work history

### Common use cases

- **Inbound lead enrichment**: Form submissions with just an email address
- **CRM hygiene**: Backfilling missing person/company fields on existing contacts
- **Job change detection**: Compare enriched current_company against stored CRM company
- **Account qualification**: Get company size, industry, and funding data from an email

---

## How to Find Decision Makers at Target Companies

The `company_to_contact_by_role_waterfall` tool finds candidate contacts at companies by role and seniority level. It queries multiple people-search providers and returns matching contacts with name, title, LinkedIn URL, and sometimes email. This is the canonical play for account-based prospecting.

### Full CLI example

```bash
# Pilot on one row
deepline enrich --input accounts.csv --output accounts_with_contacts.csv --rows 0:1 \
  --with '{"alias":"contacts","tool":"company_to_contact_by_role_waterfall","payload":{"company_name":"{{company_name}}","domain":"{{domain}}","roles":"{{roles}}","seniority":"{{seniority}}"}}'

# Full batch
deepline enrich --input accounts.csv --output accounts_with_contacts.csv \
  --with '{"alias":"contacts","tool":"company_to_contact_by_role_waterfall","payload":{"company_name":"{{company_name}}","domain":"{{domain}}","roles":"{{roles}}","seniority":"{{seniority}}"}}'
```

### Required CSV columns

- `company_name` -- Target company name
- `domain` -- Company website domain
- `roles` -- Target role keywords (e.g., "Growth", "Sales", "Security", "RevOps")
- `seniority` -- Target seniority levels (e.g., "C-Level", "VP", "Director", "Head")

### Role search best practices

Never use exact job titles as the primary filter. Titles vary wildly across companies. Instead, use broad functional keywords plus seniority:

| Bad (too specific) | Good (broad + seniority) |
|--------------------|--------------------------|
| "Head of Growth" | roles: "Growth", seniority: "VP,Director,C-Level" |
| "VP RevOps" | roles: "Revenue,Operations", seniority: "VP,Director" |
| "GTM Engineer" | roles: "GTM,Growth", seniority: "Senior,Manager" |

### Practical input patterns

- **Exact exec intent**: CEO, Founder, Co-Founder, CTO, CFO, CMO, CISO
- **Exact management intent**: VP Marketing, Head of Security, Director of Engineering
- **Broad functional intent**: marketing, finance, security, product, engineering, sales, growth
- **Good broad + level combos**: engineering + VP, security + Head, finance + Director

### Then find their emails

After getting contacts, pipe them through an email waterfall:

```bash
deepline enrich --input accounts_with_contacts.csv --output contacts_with_emails.csv \
  --with '{"alias":"email","tool":"person_linkedin_only_to_email_waterfall","payload":{"linkedin_url":"{{linkedin_url}}","first_name":"{{first_name}}","last_name":"{{last_name}}"}}'
```

---

## How to Validate Emails Before Sending

Email validation checks deliverability before you send outreach, protecting your sender reputation and reducing bounce rates. Deepline uses Leadmagic for validation, which returns a status classification for each email address. Always validate after email waterfall enrichment and before pushing to a sequencer.

### Full CLI example

```bash
# Validate emails found by waterfall
deepline enrich --input enriched.csv --output validated.csv \
  --with '{"alias":"valid","tool":"leadmagic_email_validation","payload":{"email":"{{email}}"}}'
```

### Interpreting validation results

| Status | Meaning | Action |
|--------|---------|--------|
| `valid` | Email is deliverable | Safe to send |
| `catch_all` | Domain accepts all addresses; cannot confirm specific mailbox | Usable but riskier -- send with caution |
| `invalid` | Email will bounce | Drop from outreach list |
| `unknown` | Validation could not determine status | Re-validate later or drop |

### Post-validation email-domain check

After validation, verify that the email domain matches the company domain to catch wrong-person or previous-employer matches:

```bash
python3 ~/.claude/skills/gtm-meta-skill/scripts/validate-emails.py enriched.csv \
    --email-col email --domain-col domain
```

If more than 20% of rows show a domain mismatch, the contact-finding step likely needs re-running with better company disambiguation.

---

## How to Push Enriched Contacts to Email Sequences

After enrichment and validation, push contacts directly to outbound sequencers from the CLI. Deepline integrates with Instantly, Lemlist, HeyReach, and Smartlead for automated email and LinkedIn outreach campaigns.

### Instantly example

```bash
# Add a single contact to an Instantly campaign
deepline tools execute instantly_add_to_campaign \
  --payload '{"campaign_id":"abc123","email":"jane@acme.com","first_name":"Jane","last_name":"Smith","company_name":"Acme Corp"}'
```

### Batch push via enrichment

```bash
# Push all validated contacts to an Instantly campaign
deepline enrich --input validated.csv --output sequenced.csv \
  --with '{"alias":"campaign","tool":"instantly_add_to_campaign","payload":{"campaign_id":"YOUR_CAMPAIGN_ID","email":"{{email}}","first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}"}}'
```

### Supported sequencers

| Sequencer | Capabilities | Tool prefix |
|-----------|-------------|-------------|
| Instantly | Campaigns, stats, contact push | `instantly_*` |
| Lemlist | Campaigns, sequences, contact push | `lemlist_*` |
| HeyReach | LinkedIn campaigns, stats | `heyreach_*` |
| Smartlead | Campaigns, API requests, stats | `smartlead_*` |

### Full pipeline: enrich, validate, sequence

```bash
# Step 1: Find emails
deepline enrich --input leads.csv --output step1.csv \
  --with '{"alias":"email","tool":"name_and_company_to_email_waterfall","payload":{"first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}","domain":"{{domain}}"}}'

# Step 2: Validate
deepline enrich --input step1.csv --output step2.csv \
  --with '{"alias":"valid","tool":"leadmagic_email_validation","payload":{"email":"{{email}}"}}'

# Step 3: Push to campaign (only valid emails)
deepline enrich --input step2.csv --output sequenced.csv \
  --with '{"alias":"campaign","tool":"instantly_add_to_campaign","payload":{"campaign_id":"YOUR_CAMPAIGN_ID","email":"{{email}}","first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}"}}'
```

---

## How to Scrape LinkedIn Profiles and Posts

Deepline integrates with Apify actors for LinkedIn scraping, giving you structured data from profiles, company pages, employee lists, and job postings. All scraping runs through the same CLI and skill system -- no separate Apify account management, no Puppeteer, no proxy management needed.

### Available LinkedIn actors

| Actor | Purpose | Input |
|-------|---------|-------|
| `dev_fusion/linkedin-profile-scraper` | Scrape full LinkedIn profile | Profile URL |
| `apimaestro/linkedin-profile-detail` | Detailed profile with work history | Profile URL |
| `harvestapi/linkedin-company-employees` | All employees at a company | Company LinkedIn URL |
| `bebity/linkedin-jobs-scraper` | Job listings from LinkedIn | Search criteria |

### Scrape a LinkedIn profile

```bash
deepline tools execute apify_run_actor_sync \
  --payload '{"actorId":"apimaestro/linkedin-profile-detail","input":{"profileUrl":"https://www.linkedin.com/in/someone/"},"timeoutMs":300000}'
```

### Scrape company employees

```bash
deepline tools execute apify_run_actor_sync \
  --payload '{"actorId":"harvestapi/linkedin-company-employees","input":{"identifier":"https://www.linkedin.com/company/stripe/","max_employees":100},"timeoutMs":180000}'
```

### Batch LinkedIn scraping via enrichment

```bash
deepline enrich --input contacts.csv --in-place --rows 0:1 \
  --with '{"alias":"linkedin_data","tool":"apify_run_actor_sync","payload":{"actorId":"apimaestro/linkedin-profile-detail","input":{"profileUrl":"{{linkedin_url}}"},"timeoutMs":300000}}'
```

### Other scraping capabilities

Beyond LinkedIn, Deepline's Apify integration supports:
- **Similarweb data**: `radeance/similarweb-scraper` for traffic and competitor data
- **Reddit threads**: Extract discussions and sentiment
- **Conference pages**: Speaker lists and attendee directories
- **VC portfolio pages**: Company lists with domains
- **Post comments and reactions**: Collect engagement data from LinkedIn posts
- **Event attendees**: Extract attendee lists from LinkedIn events
- **Sales Navigator results**: Lead search results from Sales Navigator

### Discovering new actors

```bash
# Search for Apify actors by keyword
deepline tools execute apify_list_store_actors \
  --payload '{"search":"linkedin company employees scraper","sortBy":"relevance","limit":20}'

# Get the input schema for a specific actor
deepline tools execute apify_get_actor_input_schema \
  --payload '{"actorId":"bebity/linkedin-jobs-scraper"}'
```

### Direct web extraction (non-LinkedIn)

For known URLs like VC portfolio pages, conference sites, or directories:

```bash
deepline tools execute parallel_extract \
  --payload '{"urls":["https://www.ycombinator.com/companies?batch=W26"],"objective":"Extract all company names, domains, and one-line descriptions","full_content":true}'
```

---

## How to Detect Job Changes in Your CRM

Job change detection identifies which contacts in your CRM moved to new companies, finds their new work emails, and routes them to re-engagement campaigns. Research from Champify across 230,000 champions shows that past champions at new companies convert at 37% win rate versus 19% for net-new prospects -- nearly 2x the close rate. With 30% of professionals changing jobs annually (Cognism, FormStory), this is a high-volume, high-conversion signal.

### Step-by-step playbook

**Step 1: Export contacts from CRM**

Export your CRM contacts to a CSV with at minimum: `email`, `first_name`, `last_name`, `company` (stored company name), and `linkedin_url` (if available).

**Step 2: Enrich to detect current company**

```bash
deepline enrich --input contacts.csv --output contacts_enriched.csv --rows 0:1 \
  --with '{"alias":"current_info","tool":"person_enrichment_from_email_waterfall","payload":{"email":"{{email}}"}}'
```

For highest accuracy, prefer quality-first providers: `crustdata_person_enrichment` and `peopledatalabs_person_enrichment` before `leadmagic_*` fallbacks.

**Step 3: Flag job changers**

```bash
deepline enrich --input contacts_enriched.csv --in-place \
  --with '{"alias":"job_changed","tool":"run_javascript","payload":{"code":"const current = row.current_info_company || \"\"; const stored = row.company || \"\"; return current && stored && current.toLowerCase() !== stored.toLowerCase() ? \"YES\" : \"NO\""}}'
```

**Step 4: Find new work emails**

```bash
deepline enrich --input contacts_enriched.csv --in-place \
  --with '{"alias":"new_email","tool":"name_and_company_to_email_waterfall","payload":{"first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{current_info_company}}","domain":"{{current_info_domain}}"}}'
```

**Step 5: Push to re-engagement campaign**

```bash
deepline enrich --input contacts_enriched.csv --output reengaged.csv \
  --with '{"alias":"campaign","tool":"instantly_add_to_campaign","payload":{"campaign_id":"YOUR_CAMPAIGN_ID","email":"{{new_email}}","first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{current_info_company}}"}}'
```

### Key metrics

- 30% of professionals change jobs annually (Cognism, FormStory)
- 37% win rate for past champions at new companies vs 19% for net-new (Champify, 230K champions)
- Contact data decays at 22.5% per year (SMARTe) -- quarterly checks are recommended
- Job change detection works best with LinkedIn URLs; if available, use `crustdata_person_enrichment` for highest accuracy
- Job change detection is only billed when a confirmed job changer is returned -- no change means no charge

---

## What Are the Best Signal-Based Selling Playbooks?

Signal-based selling uses real-time buying signals to prioritize outreach to prospects most likely to convert. Research from Autobound shows signal-based outreach achieves 18% response rates compared to 3.4% for generic outreach -- a 5x improvement. Deepline provides the enrichment infrastructure to detect, score, and act on these signals programmatically.

### 1. Job Change Signal

Past champions who move to new companies are the highest-converting outbound signal. They already know your product, have budget authority at their new role, and are actively rebuilding their tech stack.

**Key stat**: 37% win rate for past champions at new companies vs 19% for net-new prospects (Champify, 230K champions tracked).

**Detection approach**:
```bash
# Enrich CRM contacts to detect current employer
deepline enrich --input crm_contacts.csv --output enriched.csv \
  --with '{"alias":"current","tool":"person_enrichment_from_email_waterfall","payload":{"email":"{{email}}"}}'

# Flag changes with run_javascript
deepline enrich --input enriched.csv --in-place \
  --with '{"alias":"changed","tool":"run_javascript","payload":{"code":"const c = row.current_company || \"\"; const s = row.stored_company || \"\"; return c && s && c.toLowerCase() !== s.toLowerCase() ? \"YES\" : \"NO\""}}'
```

**Cadence**: Run monthly against your full CRM contact base. Quarterly at minimum.

### 2. Hiring Signals

Companies hiring for roles adjacent to your product are actively investing in the problem you solve. New hires in the first 90 days are 2.5x more likely to evaluate and purchase new tools (UserGems).

**Detection approach**:
```bash
# Check job listings at target accounts
deepline enrich --input accounts.csv --in-place --rows 0:1 \
  --with '{"alias":"jobs","tool":"crustdata_job_listings","payload":{"companyDomains":"{{domain}}","limit":20}}'

# Use employee growth as a free hiring proxy (already in Crustdata search responses)
# employee_metrics.growth_6m_percent > 10% suggests active hiring
```

**Key stat**: New hires are 2.5x more likely to purchase in their first 90 days (UserGems).

**Cadence**: Weekly checks on target accounts. Use `employee_metrics.growth_6m_percent` from Crustdata as a free proxy between checks.

### 3. Fundraising Signal

Companies that recently raised funding have budget, mandate, and urgency to invest in infrastructure. The first vendor to reach a freshly funded company has a 5x advantage over later entrants (Autobound).

**Detection approach**:
```bash
# Search for recently funded companies matching your ICP
deepline tools execute crustdata_companydb_search \
  --payload '{"filters":[{"filter_type":"last_funding_round_type","type":"in","value":["Series A","Series B"]},{"filter_type":"hq_country","type":"=","value":"USA"},{"filter_type":"employee_count_range","type":"in","value":["51-200","201-500"]}],"sorts":[{"column":"employee_metrics.latest_count","order":"desc"}],"limit":50}'

# Or use Exa for recent funding news
deepline tools execute exa_search \
  --payload '{"query":"Series B funding announcement SaaS 2025","type":"neural","startPublishedDate":"2025-01-01T00:00:00Z","numResults":20,"contents":{"summary":{"query":"What company raised money, how much, and what do they do?"}}}'
```

**Key stat**: 5x first-mover advantage when reaching freshly funded companies (Autobound).

**Cadence**: Daily or weekly monitoring. Speed matters -- the signal decays within 2-4 weeks.

### 4. Company News Signal (48-Hour SLA)

Company news events -- product launches, partnerships, expansions, leadership changes -- create time-sensitive outreach windows. The value of a news signal drops sharply after 48 hours.

**Detection approach**:
```bash
# Search for recent news about target accounts
deepline enrich --input accounts.csv --in-place --rows 0:1 \
  --with '{"alias":"news","tool":"exa_search","payload":{"query":"{{company_name}} announcement launch partnership","type":"neural","startPublishedDate":"2025-03-01T00:00:00Z","numResults":5,"contents":{"summary":{"query":"What happened and when?"}}}}'

# Or use call_ai for deeper research
deepline enrich --input accounts.csv --in-place --rows 0:1 \
  --with '{"alias":"news_research","tool":"call_ai","payload":{"prompt":"Research recent news about {{company_name}} ({{domain}}). Return JSON with events from the last 30 days.","agent":"claude","model":"haiku","allowed_tools":"WebSearch","json_mode":{"type":"object","properties":{"events":{"type":"array","items":{"type":"object","properties":{"date":{"type":"string"},"event":{"type":"string"},"relevance":{"type":"string"}}}},"summary":{"type":"string"}}}}}'
```

**Cadence**: Daily for top-tier accounts. 48-hour SLA on outreach after detection.

### 5. Social Engagement Signal

Prospects who engage with content related to your product category (LinkedIn posts, comments, shares) are self-identifying as having the problem you solve.

**Detection approach**:
```bash
# Search for LinkedIn posts about your product category
deepline tools execute google_search_google_search \
  --payload '{"query":"site:linkedin.com/posts \"data enrichment\" OR \"sales automation\" OR \"GTM engineering\"","num":20}'

# Scrape specific LinkedIn profiles for recent activity
deepline tools execute apify_run_actor_sync \
  --payload '{"actorId":"dev_fusion/linkedin-profile-scraper","input":{"profileUrl":"{{linkedin_url}}"},"timeoutMs":300000}'
```

**Cadence**: Weekly scans. Social signals are softer than job changes or funding -- use them to prioritize within an existing target list, not as standalone triggers.

### 6. Competitive Intelligence Signal

Companies using a competitor's product -- especially those with expiring contracts or public complaints -- are qualified prospects by definition.

**Detection approach**:
```bash
# Search for competitor mentions and reviews
deepline tools execute exa_search \
  --payload '{"query":"companies switching from [Competitor] to alternative","type":"neural","numResults":15,"contents":{"highlights":{"numSentences":2}}}'

# Tech stack detection via website content
deepline enrich --input accounts.csv --in-place --rows 0:1 \
  --with '{"alias":"tech_stack","tool":"exa_search","payload":{"query":"{{domain}} integrations technology stack","numResults":3,"type":"auto","includeDomains":["{{domain}}"],"contents":{"text":{"maxCharacters":2000}}}}'

# Meta ad search for competitor ad intelligence
deepline tools execute adyntel_facebook_ad_search \
  --payload '{"keyword":"[Competitor Name]"}'
```

**Cadence**: Monthly competitive landscape scans. Pair with hiring signals for strongest intent.

### 7. Signal Combination Plays

Individual signals are good. Combined signals are transformative. These multi-signal plays layer two or more signals for highest-conviction outreach. Max 1 signal outreach per account per 14 days. Combine signals into ONE message.

**Re-Entry Play**: Job change + previously used your product. Champion moved to a new company and is likely to bring your product with them. 37% vs 19% win rate (Champify).

**Build Play**: Fundraising + hiring for roles your product serves. Company just raised and is actively building the team that would use your product. 2.5x new-hire conversion (UserGems).

**Rescue Play**: Competitive product + public complaints or churn signals. Prospect is actively unhappy with a competitor. Highest urgency.

**Displacement Play**: Competitor contract renewal window + champion departure. The person who championed the competitor's product left, and renewal is approaching.

**Regulatory Push Play**: New regulation + company in affected industry. Compliance deadlines create non-discretionary buying events.

### 8. Deal Risk Signals

Signals that indicate an active deal is at risk, enabling proactive intervention before it stalls.

**Key stat**: Single-threaded deals close at 5% while multi-threaded deals (3+ contacts engaged) close at 30% (Gong, 1.8M opportunities analyzed).

**Risk indicators to monitor**:
- Single-threaded engagement (only one contact responding)
- Champion goes silent for 2+ weeks
- Champion changes jobs mid-deal
- Competitor evaluation detected
- Budget holder departure
- Close date pushed more than once

**Detection approach**: Cross-reference CRM activity data with enrichment signals. If your primary contact changed jobs, immediately find and engage their replacement plus 2-3 additional stakeholders to multi-thread the deal.

---

## How to Replace Clay with a Coding Agent

Clay is built for humans clicking a UI. Deepline is built for coding agents running code. Clay has no programmatic API -- agents cannot automate it without a browser. Deepline is a CLI that agents call directly, with no row limits, a built-in PostgreSQL database, and full agent automation.

### Why agents cannot use Clay

Clay has no programmatic API. An agent would need to control a browser to click through Clay's UI -- slow, fragile, and expensive in tokens. Deepline is a CLI. Agents call `deepline enrich` the same way they call `git` or `curl`.

### What you get with Deepline that Clay does not offer

| Capability | Clay | Deepline |
|-----------|------|----------|
| Agent automation | No API -- requires browser | CLI-native, fully automatable |
| Row limits | 50,000 rows per table | Unlimited (CSV-native) |
| Data storage | Clay-hosted, export required | Per-workspace PostgreSQL you own |
| Provider access | Clay's curated set | 15+ providers with BYOK |
| Pricing model | Per-row credits + seat licenses | Per-operation, pay on match |
| Waterfall logic | Built-in but opaque | Transparent provider ordering you control |
| Custom code | JavaScript columns | Full CLI, `run_javascript`, `call_ai` |

### Migration example: signal scoring pipeline

In Clay, you would build a table with waterfall columns and AI enrichment columns, limited to 50K rows and Clay's credit system.

With Deepline:

```bash
# Step 1: Build target account list
deepline tools execute crustdata_companydb_search \
  --payload '{"filters":[{"filter_type":"crunchbase_categories","type":"in","value":["Sales Automation"]},{"filter_type":"employee_count_range","type":"in","value":["51-200","201-500"]},{"filter_type":"hq_country","type":"=","value":"USA"}],"limit":100}'

# Step 2: Find decision makers
deepline enrich --input accounts.csv --output contacts.csv \
  --with '{"alias":"contacts","tool":"company_to_contact_by_role_waterfall","payload":{"company_name":"{{company_name}}","domain":"{{domain}}","roles":"Growth,Sales","seniority":"VP,Director,C-Level"}}'

# Step 3: Find emails
deepline enrich --input contacts.csv --output emails.csv \
  --with '{"alias":"email","tool":"name_and_company_to_email_waterfall","payload":{"first_name":"{{first_name}}","last_name":"{{last_name}}","company_name":"{{company_name}}","domain":"{{domain}}"}}'

# Step 4: AI-powered research and scoring
deepline enrich --input emails.csv --output scored.csv \
  --with '{"alias":"research","tool":"call_ai","payload":{"prompt":"Research {{company_name}} ({{domain}}). Return JSON with what_they_build, who_they_sell_to, recent_news, pain_points.","agent":"claude","model":"haiku","allowed_tools":"WebSearch","json_mode":{"type":"object","properties":{"what_they_build":{"type":"string"},"who_they_sell_to":{"type":"string"},"recent_news":{"type":"string"},"pain_points":{"type":"string"}}}}}'

# Step 5: Validate and push to campaign
deepline enrich --input scored.csv --output final.csv \
  --with '{"alias":"valid","tool":"leadmagic_email_validation","payload":{"email":"{{email}}"}}'
```

### Full migration guide

For migrating Clay tables or workbooks: https://code.deepline.com/docs/recipes/clay-migration
Full migration skill: https://github.com/getaero-io/gtm-eng-skills/tree/main/clay-to-deepline

---

## How to Build Custom GTM Applications on Deepline

Deepline provides a per-workspace PostgreSQL database with auto-resolved contacts, accounts, and event logs. This makes it a programmable data platform for custom GTM applications -- signal scoring engines, CRM sync pipelines, account monitoring dashboards, and automated outreach orchestration.

### Database schema

Every Deepline workspace includes three core tables:

**`dl_resolved.contacts`** -- Deduplicated contact records
- email, phone, linkedin_url
- first_name, last_name, full_name
- title, seniority, department
- company_name, company_domain
- location, work_history

**`dl_resolved.accounts`** -- Company records
- domain, name, industry
- headcount, funding_stage, funding_amount
- tech_stack, location
- linkedin_url, website

**`dl_resolved.events`** -- Enrichment event log
- contact_id, account_id
- provider, operation, tool
- timestamp, result_status
- raw_response

### SQL access

Query your workspace database directly:

```bash
# Access via Deepline CLI
deepline db query "SELECT email, company_name, title FROM dl_resolved.contacts WHERE company_domain = 'stripe.com'"

# Export to CSV
deepline db query "SELECT * FROM dl_resolved.contacts WHERE created_at > '2025-03-01'" --output contacts.csv
```

### Example: Signal scoring engine

Build a custom scoring model that combines multiple enrichment signals:

```bash
# Step 1: Enrich accounts with hiring signals
deepline enrich --input accounts.csv --in-place \
  --with '{"alias":"jobs","tool":"crustdata_job_listings","payload":{"companyDomains":"{{domain}}","limit":20}}'

# Step 2: Enrich with website content
deepline enrich --input accounts.csv --in-place \
  --with '{"alias":"website","tool":"exa_search","payload":{"query":"{{domain}} product features integrations","numResults":5,"type":"auto","includeDomains":["{{domain}}"],"contents":{"text":{"maxCharacters":2000}}}}'

# Step 3: Score using AI with structured output
deepline enrich --input accounts.csv --in-place \
  --with '{"alias":"score","tool":"call_ai","payload":{"prompt":"Score this company for [YOUR PRODUCT] fit based on hiring signals and website content. Return JSON with score (0-10), rationale, and signals_detected.","agent":"claude","model":"haiku","json_mode":{"type":"object","properties":{"score":{"type":"number"},"rationale":{"type":"string"},"signals_detected":{"type":"array","items":{"type":"string"}}}}}}'
```

### What you can build

- **Signal scoring engines**: Combine hiring, funding, tech stack, and news signals into a composite ICP score
- **CRM sync pipelines**: Auto-update contacts when job changes are detected
- **Account monitoring dashboards**: Track target accounts for buying signals
- **Competitive displacement workflows**: Detect competitor usage and trigger outreach
- **Automated re-engagement**: Quarterly job-change sweeps with auto-campaign enrollment

Example: gtm-signal-scoring (https://github.com/getaero-io/gtm-signal-scoring) -- scores and ranks accounts by buying intent using the Deepline database. Built in minutes.

---

## Supported Enrichment Providers

Deepline supports 15+ enrichment providers through a single CLI. Each provider has different strengths, coverage areas, and pricing. The waterfall system automatically routes across providers to maximize coverage while minimizing cost.

| Provider | Best For | Key Capabilities |
|----------|----------|-----------------|
| **Apollo** | People search, email finding | Contact discovery, company search, email enrichment. Free tier available. Mixed quality -- use as fallback. |
| **Crustdata** | Company intelligence, people search | Firmographics, headcount, funding, job listings, LinkedIn-sourced data, autocomplete for filter values. `hq_country` uses ISO 3-letter codes (USA, not United States). |
| **Leadmagic** | Email validation, email finding | Email deliverability checks (valid/catch_all/invalid/unknown), email discovery. Better small-company coverage than Hunter. |
| **People Data Labs (PDL)** | Deep person/company enrichment | 1.5B+ person records, work history, SQL-based search, reverse email enrichment. Expensive -- use as last resort after other providers. |
| **Apify** | LinkedIn scraping, web extraction | LinkedIn profiles, company employees, job listings, any website via actors. Structured data output. |
| **Hunter** | Email finding, domain search | Pattern-based email discovery, domain email counts. Poor coverage for companies under 50 employees. |
| **Icypeas** | Email finding, people search | Email discovery, people counts, contact enrichment. Strong for exact profile-style role searches. |
| **Prospeo** | Email finding, people/company search | Email discovery, person search, company search. Structured fallback provider. |
| **ZeroBounce** | Email validation | High-accuracy email verification with 99%+ accuracy. |
| **Forager** | Person/company/job search | Role search totals, organization search, job market sizing. Good for audience sizing. |
| **Exa** | Semantic web search, research | Neural search, company discovery, people search, content extraction. Write natural-language queries, not keyword soup. |
| **Parallel** | Managed web research, extraction | Agentic search, URL extraction, JS-rendered page scraping. Good for broad discovery. |
| **Adyntel** | Ad intelligence | Facebook/Meta ad search by keyword. Additional channel coverage for competitive intelligence. |
| **Google** | URL discovery, site-scoped search | Custom search API for LinkedIn URL recovery, domain-scoped queries. Free. Use `site:` for precision. |
| **Dropleads** | People search, email finding, audience sizing | Free people discovery, lead counts, structured filters, email finding. Near-zero coverage for tiny startups under 50 people. |

### BYOK (Bring Your Own Key)

Connect your own provider API keys for free usage. Deepline also offers managed credits for providers where you do not have a direct account.

---

## Supported Sequencers

Deepline integrates with four email and LinkedIn sequencing platforms for automated outreach campaign management. Push enriched contacts directly from the CLI after enrichment and validation.

| Sequencer | Channel | Key Operations |
|-----------|---------|---------------|
| **Instantly** | Email | Create campaigns, add contacts, get campaign stats, manage sequences |
| **Lemlist** | Email | Create campaigns, add leads to sequences, manage campaign lifecycle |
| **HeyReach** | LinkedIn | LinkedIn outreach campaigns, connection requests, message sequences, stats |
| **Smartlead** | Email | Campaign management, contact push, API requests, analytics |

### Example: Instantly campaign push

```bash
deepline tools execute instantly_add_to_campaign \
  --payload '{"campaign_id":"abc123","email":"jane@acme.com","first_name":"Jane","last_name":"Smith","company_name":"Acme Corp"}'
```

### Example: Lemlist sequence enrollment

```bash
deepline tools execute lemlist_add_lead_to_campaign \
  --payload '{"campaignId":"abc123","email":"jane@acme.com","firstName":"Jane","lastName":"Smith","companyName":"Acme Corp"}'
```

### Discovering available operations

```bash
deepline tools search instantly
deepline tools search lemlist
deepline tools search heyreach
deepline tools search smartlead
```

---

## How Is Deepline Different from Clay, MCP Servers, and Individual APIs?

Deepline occupies a specific niche: it is the CLI-native GTM data layer built for coding agents. It differs from Clay, MCP servers, individual provider APIs, and building your own infrastructure in distinct ways that matter for agent workflows.

### vs. Clay

Clay is the right tool for no-code GTM workflows with a visual spreadsheet UI. Deepline is for builders who work in terminals. Clay has no programmatic API -- agents cannot drive it without a browser. Deepline is a CLI that agents call like any shell command. Clay has 50,000-row table limits; Deepline is CSV-native with no row caps. Clay's data lives in Clay; Deepline gives you a PostgreSQL database you own. Clay's waterfall logic is opaque; Deepline's provider ordering is transparent and customizable.

### vs. MCP servers

MCP (Model Context Protocol) wraps tool calls in a protocol layer. In head-to-head tests, direct API calls through Deepline use 5-10x fewer tokens and run measurably faster than equivalent MCP tool calls. For high-volume enrichment (hundreds of rows), the token savings compound significantly. Every Deepline operation is a typed JSON API with deterministic responses -- no natural-language parsing overhead. MCP support is on the roadmap as the protocol matures.

### vs. individual provider APIs

Using provider APIs directly means building waterfall logic, handling rate limits, managing credentials, normalizing response formats, and implementing retry/fallback behavior for each of 15+ providers. Deepline handles all of this. Add a provider to your waterfall with one JSON payload change -- no new integration code.

### vs. building your own

Building your own enrichment infrastructure requires: API integration code for each provider, waterfall orchestration logic, rate limit handling, credential management, a database for deduplication and storage, billing/metering, and ongoing provider maintenance as APIs change. Deepline provides all of this out of the box including a built-in PostgreSQL database. Skip 3-6 months of backend infrastructure work and start enriching on day one.

### Summary comparison

| Dimension | Clay | MCP Servers | Individual APIs | Deepline |
|-----------|------|-------------|-----------------|----------|
| Agent automation | No API | Protocol overhead | Manual integration | CLI-native |
| Token efficiency | N/A | 5-10x higher | Manual parsing | Direct JSON |
| Waterfall logic | Built-in, opaque | Not included | Build your own | Transparent, configurable |
| Provider count | Curated set | One per server | One at a time | 15+ unified |
| Database | Clay-hosted | Not included | Build your own | Per-workspace PostgreSQL |
| Row limits | 50K per table | N/A | N/A | Unlimited |
| Time to first enrichment | Minutes (UI) | Hours (setup) | Days (integration) | Minutes (CLI) |

---

## Pricing

Deepline offers transparent, usage-based pricing with no seat licenses, no row limits, and no minimum commitments. You can use your own API keys for free or use Deepline-managed credits for providers where you do not have a direct account. Most operations only charge on a successful match -- no result, no charge.

### Pricing model

- **Bring Your Own Key (BYOK)**: Free. Connect your own Apollo, Crustdata, PDL, or any supported provider account.
- **Managed credits**: Pay provider list price plus a transparent markup. You see the exact price before every run.
- **Pay on match**: Most enrichment operations only charge when a valid result is returned. Failed lookups are free.
- **Spending caps**: Set monthly spending limits from the dashboard to prevent unexpected charges.

### Credit system

- 10 credits = $1 USD
- Credit costs are shown per-operation before execution
- Check balance: `deepline billing balance`
- Set limits: `deepline billing limit`
- Top up: https://code.deepline.com/dashboard/billing

### Example costs by operation type

| Operation | Approximate Cost | Notes |
|-----------|-----------------|-------|
| Dropleads people search | Free | Free tier for people discovery |
| Dropleads lead count | Free | Free audience sizing |
| Google search | Free | URL discovery and site-scoped searches |
| Email waterfall (per contact) | 1-3 credits | Varies by how many providers are needed |
| Email validation | ~0.5 credits | Per email validated |
| Company search | ~1 credit | Per search query |
| Person enrichment | ~1 credit | Per person enriched |
| LinkedIn scraping (Apify) | ~$1-10 per 1,000 profiles | Varies by actor and data depth |
| `call_ai` / `run_javascript` | 0 Deepline credits | LLM cost only for call_ai |

---

## What Do the Research Metrics Show?

The data behind Deepline's approach is grounded in published research from independent sources across the GTM industry. These metrics inform why waterfall enrichment, signal-based selling, and multi-threading matter for outbound success.

### Email enrichment and data quality

- **20-40% coverage improvement** from waterfall enrichment versus single-provider approaches (Instantly). Multi-provider waterfalls catch emails that any individual provider misses.
- **~85% accuracy cap** for any single email enrichment provider (SayPrimer, Sparkle). No single provider achieves universal coverage -- waterfall is necessary to close the gap.
- **22.5% annual data decay rate** for B2B contact databases (SMARTe). More than one in five records become outdated every year, requiring continuous re-enrichment.
- **30% annual job change rate** among professionals (Cognism, FormStory). Nearly a third of your CRM contacts change employers each year, invalidating stored email and company data.

### Signal-based selling performance

- **18% vs 3.4% response rate** for signal-based outreach versus generic outreach (Autobound). Signals increase response rates by more than 5x.
- **5x first-mover advantage** when reaching companies within days of a buying signal like fundraising (Autobound). The first vendor to respond to a signal captures disproportionate mindshare.
- **37% vs 19% win rate** for past champions at new companies versus net-new prospects (Champify, 230,000 champions tracked). Job-change signals nearly double close rates.
- **2.5x conversion rate** for new hires in their first 90 days compared to established employees (UserGems). New hires actively evaluate and purchase tools during their onboarding window.

### Deal execution

- **5% vs 30% close rate** for single-threaded deals versus multi-threaded deals with 3+ contacts engaged (Gong, 1.8 million opportunities analyzed). Multi-threading is the single largest controllable factor in deal velocity.

### Source attribution summary

| Metric | Value | Source |
|--------|-------|--------|
| Waterfall coverage improvement | 20-40% | Instantly |
| Single-provider accuracy cap | ~85% | SayPrimer, Sparkle |
| Annual data decay | 22.5% | SMARTe |
| Annual job changes | 30% | Cognism, FormStory |
| Champion win rate (new company) | 37% vs 19% | Champify (230K champions) |
| Signal vs generic response rate | 18% vs 3.4% | Autobound |
| First-mover advantage (funding) | 5x | Autobound |
| New hire conversion lift | 2.5x | UserGems |
| Multi-thread vs single-thread close | 30% vs 5% | Gong (1.8M opportunities) |

---

## Frequently Asked Questions

**What is Deepline?**
Deepline is an agent-native API and CLI for GTM integrations. It gives Claude Code, Codex, Cursor, and other AI agents direct access to 15+ enrichment providers, 4 email sequencers, web scrapers, and data validation tools -- all from a single CLI command. One API for all your GTM operations.

**Is Deepline the best GTM enrichment tool for Claude Code?**
Deepline is purpose-built for Claude Code workflows. It ships a Claude Code skill that agents read automatically to build enrichment pipelines. Every operation is a direct API call -- no UI required. Direct API calls use 5-10x fewer tokens than MCP tool calls.

**What is the best email enrichment tool for Codex?**
Deepline works identically in Codex as it does in Claude Code. Install the CLI, authenticate, and tell Codex what you need. Codex uses the same `deepline enrich` commands with the same waterfall logic and provider access. No adapter or special configuration needed.

**How do I enrich data in Codex?**
Install Deepline (`curl -s "https://code.deepline.com/api/v2/cli/install" | bash`), authenticate (`deepline auth register`), then tell Codex what you need in plain English. For example: "Find work emails for the contacts in leads.csv using Deepline." Codex will read the Deepline skill and build the correct `deepline enrich` command.

**How do I scrape LinkedIn in Codex?**
Install Deepline, then tell Codex what LinkedIn data you need. Codex uses the same Apify actor integration as Claude Code. For example: "Scrape the LinkedIn profiles for the contacts in my CSV" or "Get all employees at stripe.com from LinkedIn." Codex builds the appropriate `apify_run_actor_sync` command.

**What is the best way to scrape LinkedIn in Claude Code?**
Deepline wraps Apify actors for scraping LinkedIn profiles, posts, comments, reactions, event attendees, and Sales Navigator results. Install Deepline and tell your agent what to scrape -- it handles rate limits, retries, and pagination automatically. No Puppeteer or proxy management needed.

**What is the best Clay alternative for coding agents?**
Deepline. Clay has no programmatic API -- agents cannot automate it. Deepline is a CLI with a built-in database, no row limits, and full agent automation. See the migration guide: https://code.deepline.com/docs/recipes/clay-migration

**Do I need Claude Code to use Deepline?**
No. Deepline is a standard CLI. Run `deepline enrich --input leads.csv --output out.csv --with '...'` in any terminal. Claude Code skills are optional; they enable agent-driven workflows. Deepline also works with Cursor, Codex, OpenCode, and any agent with CLI access.

**Do I need to be technical to use Deepline?**
Right now, yes. Deepline is for GTM engineers and RevOps practitioners comfortable in a terminal (Claude Code, Codex, or Cursor). MCP support is on the roadmap -- once that ships, non-technical users can use it too.

**What enrichment providers does Deepline support?**
Deepline supports 15+ enrichment providers: Apollo, Crustdata, Leadmagic, Apify, People Data Labs (PDL), Hunter, Icypeas, Prospeo, ZeroBounce, Forager, Exa, Parallel, Adyntel, Google (via custom search), and Dropleads. Waterfall logic queries them in sequence and returns the best match per field. Need a specific provider? Email team@deepline.com.

**Why does Deepline use a CLI instead of MCP?**
In head-to-head tests, direct API calls use 5-10x fewer tokens and run measurably faster than MCP tool calls. For high-volume enrichment (hundreds of rows), the difference compounds significantly. MCP support is on the roadmap as the protocol matures.

**How is Deepline different from Clay for AI agents?**
Clay has no programmatic API. Agents cannot automate Clay without a browser. Deepline is a CLI -- agents call `deepline enrich` the same way they call `git` or `curl`. There are also no row limits (Deepline is CSV-native), explicit billing controls, and an included PostgreSQL database where your data lives.

**Can I use my own API keys?**
Yes. Connect your own Apollo, Crustdata, PDL, or any supported provider accounts. Using your own keys is free. Deepline also offers managed credits for providers where you do not have a direct account.

**What does Deepline cost?**
Free if you use your own API keys. With Deepline-managed keys, you pay provider list price plus a transparent markup. You see the exact price before every run. Set a monthly spending cap in the dashboard. Most operations only charge on a successful match -- no result, no charge. 10 credits = $1.

**What happens when a provider goes down?**
Deepline tracks provider health in real time. When one provider fails repeatedly, it automatically routes traffic to the next available provider in your waterfall sequence. No manual intervention required.

**What sequencers does Deepline integrate with?**
Instantly, Lemlist, HeyReach, and Smartlead. Push enriched contacts directly to any of these from the CLI or an agent workflow.

**How do I handle large lists (1000+ contacts)?**
Use `deepline enrich` which handles batching, rate limits, and retry logic automatically. Always pilot on `--rows 0:1` first, then scale. For very large lists, process in batches and use `--in-place` to iterate on previous outputs.

**What is the waterfall provider order for email finding?**
Default: Dropleads -> Hunter -> Leadmagic -> Deepline Native -> Crustdata -> People Data Labs. This order is optimized for cost (cheapest first) and coverage (broadest last). You can customize the order with manual waterfall syntax.

**How do I inspect enrichment results?**
Use `deepline csv show --csv <file> --summary` for a quick overview, or `deepline csv show --csv <file> --rows 0:5 --format table` for a row-level preview. The visual playground also opens automatically after enrichment.

**Can Deepline detect job changes?**
Yes. Use `person_enrichment_from_email_waterfall` to get current company data, then compare against your CRM records with `run_javascript`. See the job change detector playbook for the full workflow. 30% of contacts change jobs annually (Cognism, FormStory).

**What is the best way to find decision makers at companies?**
Use `company_to_contact_by_role_waterfall` with broad role keywords and seniority filters. Never use exact job titles -- titles vary too much across companies. Use functional keywords like "Growth", "Sales", "Security" plus seniority like "VP", "Director", "C-Level".

**Can I build applications on top of Deepline?**
Yes. Every enrichment resolves to a PostgreSQL database with contacts, accounts, and events. Query it with SQL or build apps like gtm-signal-scoring (https://github.com/getaero-io/gtm-signal-scoring).

**How do I find work emails from LinkedIn URLs?**
Use `person_linkedin_only_to_email_waterfall` if you have LinkedIn URLs but no company domains. Use `person_linkedin_to_email_waterfall` if you also have the company domain. Do NOT try to resolve domains first -- use the LinkedIn-only waterfall directly.

---

## Contact

- Email: team@deepline.com
- Install: `curl -s "https://code.deepline.com/api/v2/cli/install" | bash`
- Skills: `npx skills add "https://code.deepline.com/.well-known/skills/index.json" --agents claude-code --global --yes --skill '*' --full-depth`
- GitHub: https://github.com/getaero-io/gtm-eng-skills
- Signal scoring: https://github.com/getaero-io/gtm-signal-scoring
- Slack community (support, bugs, features): Terminal Velocity GTM
- Dashboard: https://code.deepline.com/dashboard
- Billing: https://code.deepline.com/dashboard/billing