Free Company Search Database

Use free_simple_company_search to query a shared company dataset with SQL. It is for exact resolution, bounded list building, and coverage review—not live web discovery. This Deepline Native tool reads a shared Snowflake companies table of roughly 35 million source records. It does not call a live provider API. Deepline loads a People Data Labs CSV snapshot into the read-only table.

free_simple_company_search and materialize_free_customer_companies have no Deepline credit charge. They are still bounded: broad queries can time out, and Deepline limits each workspace to five requests per second.

What it is for

Use the free database when your question can be answered by the snapshot’s domain, company name, LinkedIn company URL, industry, location, employee-size bucket, or founding year.

Use case	Query shape	What to review
Resolve CRM domains	Exact `normalized_domain` equality or `IN` lookup	Confirm the returned name and LinkedIn URL before treating it as the CRM account.
Clean a normalized target list	Small batch lookup by normalized domain, then use the returned snapshot fields	Keep unmatched input domains separate; an absence is not proof that the company no longer exists.
Build a pilot segment	Narrow industry, location, size, and founding-year predicates with a small `LIMIT`	Inspect the first page before increasing the limit or materializing rows.
Check coverage or corpus-side duplicates	`COUNT(DISTINCT normalized_domain)` and bounded `GROUP BY` queries	Compare against your unique input-domain count outside the tool. The snapshot can contain multiple source rows for a domain.

For a name-only fallback, use an anchored prefix such as company_name ILIKE 'acme%', then verify the resulting domain. Do not treat a fuzzy name match as an identity match. Use a provider-native company search instead when you need live web coverage, advanced facets, funding or investor filters, hiring signals, strict market sizing totals, or semantic discovery by what a company does. For newly discovered funding rounds, use the Funding data feed.

Snapshot and schema

The production loader expects the raw PDL company CSV header:

country,founded,id,industry,linkedin_url,locality,name,region,size,website

Deepline transforms that source into the query table:

Source field	Deepline column
`id`	`source_record_id`
`website`	`domain`, `normalized_domain`
`name`	`company_name`
`industry`	`industry`
`locality`, `region`, `country`	`location`
`linkedin_url`	`linkedin_url`
`size`	`employee_count`
`founded`	`year_founded`

updated_at is set during Deepline’s table load. It should be read as import/update time for this corpus, not as proof that PDL recently observed the company.

Schema

Query the table as companies. public.companies also works for compatibility.

Column	Type	Notes
`source_record_id`	text	Source row id from the snapshot.
`normalized_domain`	text	Lowercase root domain with protocol, `www.`, path, and trailing dot removed. Fastest lookup key when you have a domain.
`domain`	text	Original website/domain from the source.
`company_name`	text	Company name. Required in the loaded table.
`industry`	text	Source industry label, for example `Computer Software`.
`location`	text	Comma-separated locality, region, country.
`linkedin_url`	text	LinkedIn company URL or slug from the source.
`employee_count`	integer	Upper bound of the source size bucket: `10`, `50`, `200`, `500`, `1000`, `5000`, `10000`, or `10001` for `10000+`.
`year_founded`	integer	Source founding year when present.
`updated_at`	timestamp	Deepline load/update timestamp.

Start from the CLI

Inspect the live tool schema first:

deepline tools describe free_simple_company_search --json

Then run one bounded query. This exact-domain lookup is the safest starting point for a CRM or CSV export that already contains normalized domains:

PAYLOAD=$(cat <<'JSON'
{
  "sql": "SELECT normalized_domain, domain, company_name, industry, location, employee_count, year_founded FROM companies WHERE normalized_domain = 'openai.com' LIMIT 5"
}
JSON
)

deepline tools execute free_simple_company_search --input "$PAYLOAD"
deepline tools execute free_simple_company_search --input "$PAYLOAD" --out companies.csv

The direct command returns matching rows; --out writes row-shaped results to CSV. It does not modify the Database or the shared snapshot.

Practical SQL patterns

Resolve and normalize a target list

Normalize website values to lowercase root domains before putting them in the IN list. The output gives you the snapshot’s company name and LinkedIn URL for review; it does not automatically overwrite CRM values.

SELECT normalized_domain, company_name, linkedin_url
FROM companies
WHERE normalized_domain IN ('openai.com', 'anthropic.com', 'vercel.com')
LIMIT 10

For a small list that already has LinkedIn company URLs, use exact equality or IN as well:

SELECT company_name, normalized_domain, linkedin_url
FROM companies
WHERE linkedin_url IN ('linkedin.com/company/openai')
LIMIT 5

Find candidates after an exact miss

Use a prefix only after an exact domain, LinkedIn URL, or company-name lookup misses. Inspect the returned domain before using a candidate downstream:

SELECT company_name, normalized_domain, location, employee_count
FROM companies
WHERE company_name ILIKE 'acme%'
LIMIT 25

Build a bounded pilot segment

First count a narrowly defined segment, then request a small page. Employee count is the upper bound of a source size bucket, not a live headcount.

SELECT COUNT(*) AS company_count
FROM companies
WHERE industry ILIKE '%software%'
  AND employee_count >= 50
LIMIT 1

SELECT normalized_domain, company_name, industry, location, employee_count, year_founded
FROM companies
WHERE location ILIKE 'san francisco%'
  AND year_founded >= 2020
ORDER BY employee_count DESC
LIMIT 100

Check coverage and source duplicates

Compare matched_domains with the number of unique normalized domains in your input file. Unmatched domains do not appear in the result, so this tool cannot label them as missing for you.

SELECT
  COUNT(*) AS source_records,
  COUNT(DISTINCT normalized_domain) AS matched_domains
FROM companies
WHERE normalized_domain IN ('openai.com', 'anthropic.com', 'vercel.com')
LIMIT 1

This query checks duplicate source records for the requested domains. It does not detect duplicate rows in your CRM or CSV.

SELECT normalized_domain, COUNT(*) AS source_record_count
FROM companies
WHERE normalized_domain IN ('openai.com', 'anthropic.com', 'vercel.com')
GROUP BY normalized_domain
HAVING COUNT(*) > 1
LIMIT 20

Query from the API

Use the normal tool execution endpoint:

curl -X POST "https://code.deepline.com/api/v2/integrations/free_simple_company_search/execute" \
  -H "Authorization: Bearer $DEEPLINE_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @- <<'JSON'
{
    "payload": {
      "sql": "SELECT normalized_domain, company_name FROM companies WHERE normalized_domain = 'openai.com' LIMIT 5"
    }
}
JSON

The response wraps the SQL result in data:

{
  "data": {
    "schema": "public.companies",
    "command": "SELECT",
    "row_count_returned": 1,
    "truncated": false,
    "columns": [
      { "name": "company_name", "table_id": null, "data_type_id": null }
    ],
    "sql": "SELECT company_name FROM companies WHERE normalized_domain = 'openai.com' LIMIT 5",
    "executed_sql": "SELECT company_name FROM COMPANIES WHERE normalized_domain = 'openai.com' LIMIT 5",
    "limit": 5,
    "rows": [{ "company_name": "OpenAI" }]
  }
}

SQL rules and limits

SQL must be a single statement.
Only SELECT, WITH, or EXPLAIN statements are allowed.
The statement must read from companies or public.companies.
A top-level LIMIT is required and must be 100000 or less.
Queries have a 30-second Snowflake timeout. Broad ILIKE '%keyword%', long OR chains, large country-wide scans, and expensive GROUP BY shapes can time out.
Workspaces are rate-limited to five requests per second.
Matching records are returned in rows. Use deepline tools execute free_simple_company_search --input "$PAYLOAD" --out companies.csv when you want to save direct CLI results as CSV.

Use inside a Play

Inside a Play, call the tool through ctx.tools.execute. Row-shaped extracted list getters return a Dataset Handle. Pass the rows through the Play output or into another ctx.dataset stage.

import { definePlay } from 'deepline';

export default definePlay('free-company-search', async (ctx) => {
  const result = await ctx.tools.execute({
    id: 'free_company_search',
    tool: 'free_simple_company_search',
    input: {
      sql: "SELECT normalized_domain, company_name, industry, location FROM companies WHERE location ILIKE 'san francisco%' LIMIT 100",
    },
    description: 'Find matching companies from the free company corpus.',
  });

  const companies = result.extractedLists.rows.get();

  return {
    companies,
    count: await companies.count(),
  };
});

After the Play run completes, use the emitted run ID to export the returned dataset:

RUN_ID_FILE="./free-company-search-run.json"
deepline plays run --file ./free-company-search.play.ts --watch --run-id-file "$RUN_ID_FILE"
RUN_ID="$(jq -er '.runId' "$RUN_ID_FILE")"
deepline runs export "$RUN_ID" --dataset result.companies --out companies.csv

Save matching companies to your workspace database

To save query results in your Database, use materialize_free_customer_companies. It runs the SQL query and upserts rows into enrichments.companies. The query must return only these company columns:

domain, company_name, industry, location, linkedin_url, employee_count, year_founded

Example:

PAYLOAD=$(cat <<'JSON'
{
  "sql": "SELECT normalized_domain AS domain, company_name, industry, location, linkedin_url, employee_count, year_founded FROM companies WHERE industry ILIKE '%software%' AND employee_count >= 50 LIMIT 1000"
}
JSON
)

deepline tools execute materialize_free_customer_companies --input "$PAYLOAD"

Then query the saved rows with query_customer_db:

deepline tools execute query_customer_db --input '{
  "sql": "SELECT domain, company_name, industry, employee_count FROM enrichments.companies ORDER BY updated_at DESC LIMIT 50"
}'

TAM builder guidance

For TAM work, start here when the ICP can be expressed with exact domains, company names, LinkedIn company URLs, industry, location, employee count, or founding year. Escalate to Dropleads, Apollo, Crustdata, Exa, or known-source extraction when the needed signal is not in this schema.

Get started

Build and automate

Common workflows

Data and integrations

Reference

Free Company Search Database

What it is for

Snapshot and schema

Schema

Start from the CLI

Practical SQL patterns

Resolve and normalize a target list

Find candidates after an exact miss

Build a bounded pilot segment

Check coverage and source duplicates

Query from the API

SQL rules and limits

Use inside a Play

Save matching companies to your workspace database

TAM builder guidance

​What it is for

​Snapshot and schema

​Schema

​Start from the CLI

​Practical SQL patterns

​Resolve and normalize a target list

​Find candidates after an exact miss

​Build a bounded pilot segment

​Check coverage and source duplicates

​Query from the API

​SQL rules and limits

​Use inside a Play

​Save matching companies to your workspace database

​TAM builder guidance

What it is for

Snapshot and schema

Schema

Start from the CLI

Practical SQL patterns

Resolve and normalize a target list

Find candidates after an exact miss

Build a bounded pilot segment

Check coverage and source duplicates

Query from the API

SQL rules and limits

Use inside a Play

Save matching companies to your workspace database

TAM builder guidance