Free Business Leads API: What You Can Build with 100 Requests per Month

If you want to build a lead generation workflow, the fastest useful starting point is not a giant database subscription or a fragile browser scraper. It is a small, reliable API test that answers one practical question: can you turn a location and a business category into structured prospects your tools can actually use? BizCollect is a free business leads API built for that exact first step. You send one request with location, keywords, radius_km, and scrape_emails, receive an async job_id, then poll for structured JSON with businesses, addresses, phone numbers, websites, and deduped contact emails extracted from business websites. The free tier currently starts with 200 signup credits and no credit card required, subject to the current terms on pricing.

Why a Free Business Leads API Is Useful

Most people do not need a massive lead database on day one. They need a controlled way to test whether a market, workflow, sales motion, or automation idea is worth more investment. A free lead generation API is useful because it lets you validate the shape of your data pipeline before you pay for volume.

Lead generation is rarely just "get a list." A working system usually needs to:

Search a specific local market.
Collect business names, addresses, phone numbers, and websites.
Extract public contact emails where available.
Deduplicate records before they reach a CRM.
Map fields into a spreadsheet, database, CRM, or automation tool.
Trigger follow-up steps without manual copy and paste.

If your source data arrives as inconsistent HTML, screenshots, or browser automation output, the rest of the workflow becomes harder to trust. You spend time fixing selectors, parsing messy pages, and cleaning fields instead of learning whether the prospects are useful.

BizCollect is designed as an LLM-native business contacts API, which means the interface is built for AI agents, scripts, no-code tools, and backend services. The request is explicit. The response is structured. The job lifecycle is predictable. You can read the OpenAPI 3.1 reference in the docs, generate a client, or wire the endpoint directly into tools such as n8n, Make, Zapier, a custom GPT action, a CRM enrichment script, or an internal sales dashboard.

What You Get from BizCollect

The core workflow is intentionally simple:

Send a POST request with a location, keywords, search radius, and email extraction preference.
Receive a job_id.
Poll the job endpoint until the job is complete.
Process structured business records.

A completed result can include fields such as:

Business name
Address
Phone number
Website
Deduped contact emails found on the business website

That combination is what makes the API useful for local prospecting. A plain place search can tell you that a business exists. A business contacts API free tier is more useful when it lets you test the full path from search to usable contact record.

BizCollect also avoids a common maintenance problem: browser selectors. If you build your lead generation workflow by driving a headless browser through search pages, you inherit all of the fragility of page layouts, anti-bot interruptions, dynamic loading, and scraper-specific parsing. With BizCollect, your application talks to an API contract instead. You still need to handle normal API concerns such as authentication, status polling, retries, and plan limits, but you do not need to maintain a browser scraper just to get local business leads into JSON.

What 200 Signup Credits Can Actually Prove

Two hundred signup credits are not meant to power an enterprise outbound program by themselves. They are enough to run serious tests before you scale.

Think of each request as a search job. The exact number of businesses returned by a job can vary by location, category, radius, data availability, and whether websites expose public contact emails. Do not plan a workflow around a guaranteed result count per request. Instead, budget requests around questions you want to answer:

Is this niche dense enough in a target city?
Do businesses in this category usually have websites?
Are public contact emails available often enough to support outreach?
Does the JSON schema map cleanly into my CRM?
Can an AI agent call the API, wait for results, and summarize the output?
Can a no-code workflow run the full loop without manual intervention?

That is the right mindset for a free local business leads free API tier. Use it to learn, not to assume. When the workflow is proven, review pricing for current limits and paid options.

A Simple Monthly Budget

A practical monthly allocation might look like this:

20 requests for niche and market research.
20 requests for agency prospect list experiments.
20 requests for CRM enrichment tests.
20 requests for weekly monitoring workflows.
10 requests for AI agent prototypes.
10 requests for no-code proof-of-concept runs.

Shift the budget depending on your goal. A solo consultant may spend most requests testing industries and cities. A developer may spend more on integration and error handling. An agency may reserve requests for client-specific samples.

Project 1: Build a Niche Market Sample

A niche market sample is one of the best first projects for a free business leads API. Instead of trying to build a broad list, choose a narrow category and a specific geography.

For example:

Independent accountants within 20 km of Austin
Dental clinics within 15 km of Zurich
Roofing contractors within 25 km of Denver
Wedding photographers within 30 km of Manchester
Veterinary clinics within 20 km of Toronto

The goal is not to exhaust the market. The goal is to understand whether the niche is promising: website availability, public contact emails, address quality, phone coverage, and category fit.

For each market sample, record:

Search inputs used: location, keywords, radius, and email setting.
Number of returned businesses.
Number of records with websites.
Number of records with public contact emails.
Obvious mismatches or irrelevant categories.
Fields required by your downstream workflow.

Avoid over-optimizing after one request. A better sample uses a few carefully chosen requests and compares the output across nearby cities or keyword variations.

Project 2: Create an Agency Prospect List

Agencies often need a small but relevant prospect list before launching a campaign. A web design agency may want local businesses with websites that need review. A paid ads agency may want clinics, contractors, or professional services firms in a specific region. A local SEO agency may want businesses in categories where online presence matters.

A free lead generation API is useful here because it lets you build a prospect list sample without buying a broad database. You can search a territory, collect structured business details, and move the records into a spreadsheet or CRM for manual qualification.

A practical agency workflow could look like this:

Pick one service offer, such as local SEO audits.
Choose one business category, such as dentists or roofers.
Choose one city or metro area.
Run a small number of BizCollect search jobs.
Export businesses with websites and public contact emails.
Manually review websites for fit.
Add qualified records to a CRM segment.

This keeps the list small enough to review properly and gives you a better sales signal than a generic purchased list because your team controls the location, category, and radius.

Request Budget Example for an Agency

An agency could spend 30 monthly requests like this:

10 requests for one primary niche across nearby cities.
10 requests for a second niche to compare response quality.
5 requests for keyword variations in the best-performing niche.
5 requests for workflow testing into a CRM or spreadsheet.

That is enough to compare markets without assuming that one keyword or city represents the whole opportunity.

Project 3: Test CRM Enrichment

Many teams already have leads in a CRM, but the records are incomplete. Some are missing websites. Some have phone numbers but no public emails. Some have a business name and city but no structured address. A business contacts API free tier is a good way to test whether API-based enrichment fits your data model.

Start with a small CRM export. Do not upload your entire database into a new workflow on day one. Choose a sample, such as 25 to 50 records, and define what "enriched" means for your team.

For example:

Add website if missing.
Add phone if missing.
Add public contact emails where available.
Normalize address fields.
Flag records that need manual review.
Skip records that already have complete data.

BizCollect searches by location and keywords, so CRM enrichment works best when your source record can be translated into a clear local search. If you know the business category and city, you can run targeted searches and match returned records against existing CRM entries by business name, website, phone, or address.

For a first test, avoid automatically overwriting CRM fields. Write enriched data to separate fields or a review sheet:

bizcollect_website
bizcollect_phone
bizcollect_emails
bizcollect_address
bizcollect_match_notes

Then compare the results manually. Once the matching logic is reliable, you can automate more of the update process. With 200 signup credits, you can run several batches, test matching rules, and confirm whether async polling fits your CRM environment before you scale.

Project 4: Run a Weekly Monitoring Workflow

Lead generation is not always a one-time export. Some teams want to monitor a market every week. For example, an agency might track new restaurants in a city, a supplier might watch for new clinics, or a SaaS company might monitor local service businesses in expansion markets.

A weekly monitoring workflow can be small and still valuable. With 200 signup credits plus daily login credits, you can reserve part of the balance for testing and use the rest on recurring checks. That might cover several categories in one city or one category across multiple cities.

The workflow is straightforward:

Schedule a weekly run.
Send BizCollect search requests for the chosen markets.
Poll each job until completion.
Compare returned businesses against a stored database.
Add new records to a review queue.
Notify the team in Slack, email, or a CRM task list.

The key step is comparison. Do not treat every weekly result as new. Store prior records and dedupe using stable combinations such as website, phone, business name, and address.

Request Budget Example for Monitoring

A weekly monitoring plan might use:

4 requests per week for "dentist" across four cities.
4 requests per week for "orthodontist" across the same cities.
4 requests per week for "dental clinic" as a broader category.

That is roughly 48 requests over four weeks. Use the rest for workflow changes, keyword tests, or a second monitored category. If the workflow proves valuable, plan production volume from pricing.

Project 5: Prototype an AI Lead Generation Agent

AI agents are good at planning and orchestration, but they need dependable tools. A model should not invent local businesses from memory or scrape search pages through an uncontrolled browser session. It should call a clear tool, pass structured arguments, wait for the result, and then reason over the returned records.

BizCollect is built for that pattern. You can expose the API to an agent as a tool with parameters such as:

location
keywords
radius_km
scrape_emails

The agent can ask the user a natural-language question, turn the answer into API inputs, create a job, poll for completion, then summarize the businesses or pass them into another system.

For example, a user might say:

Find independent gyms within 10 km of Phoenix and collect public contact emails where available.

The agent should translate a request like that into API inputs, not improvise a list. Once the result arrives, the model can help with higher-level tasks:

Classify likely fit.
Group businesses by city or category.
Draft review notes.
Create CRM-ready summaries.
Identify records missing websites or emails.
Ask a human to approve outreach.

With 200 signup credits, you can test tool calling, async polling, field mapping, and human review loops before attaching larger budgets or production systems.

Project 6: Build a No-Code Workflow Proof of Concept

No-code tools are a natural fit for a local business leads free API because the workflow is mostly orchestration: an HTTP request, a wait step, a polling loop, and a destination.

Tools such as n8n, Make, and Zapier can follow the same pattern:

Trigger manually, on a schedule, or from a form.
Send a POST request to create a BizCollect job.
Store the job_id.
Wait for a short interval.
Poll the job endpoint.
Branch based on status.
Send completed business records to Google Sheets, Airtable, HubSpot, Pipedrive, Notion, or Slack.

The free tier is especially useful for no-code proof of concept work because mistakes are normal. You may need to adjust JSON paths, retry settings, field mapping, item splitting, and deduplication logic before the workflow is ready.

For more implementation ideas, browse the use cases and the API reference in the docs.

API Example: Create a Search Job with curl

Use the exact base URL, authentication header, and response fields shown in your BizCollect account and the canonical docs. This example shows the general flow.

curl -X POST "https://bizcollect.dev/api/v1/search" \
  -H "Authorization: Bearer $BIZCOLLECT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "location": "Austin, TX",
    "keywords": ["accounting firm", "tax advisor"],
    "radius_km": 20,
    "scrape_emails": true
  }'

The response returns an async job identifier:

{
  "job_id": "job_123456",
  "status": "queued",
  "poll_url": "/api/v1/jobs/job_123456"
}

Then poll for completion:

curl -X GET "https://bizcollect.dev/api/v1/jobs/job_123456" \
  -H "Authorization: Bearer $BIZCOLLECT_API_KEY"

A completed job returns structured records. Treat the documentation as the source of truth for the current schema, but a representative result looks like this:

{
  "job_id": "job_123456",
  "status": "completed",
  "businesses": [
    {
      "name": "Example Accounting Group",
      "address": "123 Main St, Austin, TX 78701",
      "phone": "+1 512-555-0101",
      "website": "https://example-accounting.com",
      "emails": ["hello@example-accounting.com"]
    }
  ]
}

That is the practical advantage of an API over a scraper output file: your next step can map name, address, phone, website, and emails into the system that needs them.

JavaScript Example: Start and Poll a Job

This example uses plain fetch. In production, add stronger timeout handling, retries, logging, and status-specific error handling.

const API_KEY = process.env.BIZCOLLECT_API_KEY;
const BASE_URL = "https://bizcollect.dev";

async function createSearchJob() {
  const response = await fetch(`${BASE_URL}/api/v1/search`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      location: "Denver, CO",
      keywords: ["roofing contractor"],
      radius_km: 25,
      scrape_emails: true,
    }),
  });

  if (!response.ok) {
    throw new Error(`Search request failed: ${response.status}`);
  }

  return response.json();
}

async function pollJob(jobId) {
  for (let attempt = 0; attempt < 30; attempt += 1) {
    const response = await fetch(`${BASE_URL}/api/v1/jobs/${jobId}`, {
      headers: {
        Authorization: `Bearer ${API_KEY}`,
      },
    });

    if (!response.ok) {
      throw new Error(`Polling failed: ${response.status}`);
    }

    const job = await response.json();

    if (job.status === "completed") {
      return job.businesses || [];
    }

    if (job.status === "failed") {
      throw new Error(`BizCollect job failed: ${jobId}`);
    }

    await new Promise((resolve) => setTimeout(resolve, 5000));
  }

  throw new Error(`Timed out waiting for job: ${jobId}`);
}

const job = await createSearchJob();
const businesses = await pollJob(job.job_id);

console.log(JSON.stringify(businesses, null, 2));

For an AI agent, the same logic can sit behind a tool call. The model supplies the search parameters. Your code enforces limits, validates inputs, creates the job, polls safely, and returns only the fields the model needs.

Python Example: Collect Leads for a Small Test

Python is a good fit for one-off testing, CRM enrichment experiments, and scheduled scripts.

import os
import time
import requests

API_KEY = os.environ["BIZCOLLECT_API_KEY"]
BASE_URL = "https://bizcollect.dev"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

payload = {
    "location": "Toronto, ON",
    "keywords": ["veterinary clinic"],
    "radius_km": 20,
    "scrape_emails": True,
}

create_response = requests.post(
    f"{BASE_URL}/api/v1/search",
    headers=headers,
    json=payload,
    timeout=30,
)
create_response.raise_for_status()

job = create_response.json()
job_id = job["job_id"]

for _ in range(30):
    poll_response = requests.get(
        f"{BASE_URL}/api/v1/jobs/{job_id}",
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=30,
    )
    poll_response.raise_for_status()

    status = poll_response.json()

    if status["status"] == "completed":
        for business in status.get("businesses", []):
            print({
                "name": business.get("name"),
                "phone": business.get("phone"),
                "website": business.get("website"),
                "emails": business.get("emails", []),
            })
        break

    if status["status"] == "failed":
        raise RuntimeError(f"BizCollect job failed: {job_id}")

    time.sleep(5)
else:
    raise TimeoutError(f"Timed out waiting for job: {job_id}")

Once this script works, add CSV export, database inserts, HubSpot updates, or a dedupe step.

How to Budget Requests Without Guessing Results

The safest way to plan your 200 signup credits is to budget by experiment, not by expected lead count. Local business density varies, and some businesses publish emails more clearly than others. Use this planning model instead:

Discovery Budget

Spend 20 to 30 requests learning which markets are worth deeper testing. Track which locations and keyword phrases return relevant records and usable contact fields.

Integration Budget

Reserve 20 to 30 requests for authentication, JSON parsing, async polling, retries, CRM mapping, and no-code configuration.

Qualification Budget

Use 20 to 30 requests to build manually reviewed prospect samples and check website quality, relevance, category fit, and outreach readiness.

Reserve Budget

Keep 10 to 20 requests unallocated for mistakes, schema checks, demos, or a promising idea that appears mid-month.

Common Mistakes to Avoid

Treating API output as a finished sales strategy. You still need positioning, qualification criteria, compliance review, and respectful outreach practices.
Skipping deduplication in your own system. Your CRM may receive the same business through multiple keyword searches, nearby locations, or weekly monitoring runs.
Designing around a single perfect request. Real workflows need retries, timeouts, failed-job handling, and empty-result handling.
Automating every decision immediately. For early tests, keep a human review step before outreach.
Ignoring plan terms. The free tier is currently 200 signup credits with no credit card required, but plan limits and pricing can change. Check pricing before planning production usage.

When to Move Beyond the Free Tier

The free tier is the right place to start when validating an idea. It is probably time to move beyond it when:

You have a repeatable market or keyword strategy.
Your workflow reliably polls jobs and handles errors.
CRM mapping is tested.
Manual review confirms that the records are useful.
Weekly or daily monitoring would consume most of the free monthly allowance.
Multiple users or clients need separate prospecting workflows.

At that point, your question changes from "Can this work?" to "How much volume do we need, and what is the operational value of the data?" That is the right time to compare plans on pricing.

Start Building with BizCollect

BizCollect gives you a practical starting point for local lead generation: a free business leads API with 200 signup credits, no credit card required, and an API contract designed for scripts, AI agents, no-code tools, and CRM enrichment. The free tier is subject to the current pricing terms, so confirm the latest limits on pricing.

Start with one narrow use case. Pick a location, choose a category, set a radius, enable scrape_emails if contact discovery matters, and run your first async job. Then poll the result, inspect the structured JSON, and map the fields into the tool you already use.

For implementation details, open the docs. For workflow ideas, browse use cases. If your goal is to validate a free lead generation API before building a full prospecting system, 200 signup credits is enough to learn what matters and decide what to build next.