How to Test B2B Lead Gen Providers for Customer Support (Before You Pay)

Rate a provider's support the way you would rate its API: send it known-bad input and measure what comes back. Ratings pages tell you how people felt. This test tells you how the vendor behaves when you are blocked.

TL;DR

• Support quality shows up in four places: error bodies, rate-limit headers, the plan's support channel and the time to a first human reply.
• The test takes about 30 minutes of work, plus waiting for the ticket reply. Run it on the free plan of every vendor on your shortlist.
• On LeadOcean it spends 0 records: counts, account reads and documented errors are free. A 402 or 429 costs nothing either.

Prerequisites

• A free key from each vendor you are testing. For LeadOcean, https://app.leadocean.io/register, no card.
• curl and jq.
• Your key in the shell: export LEADOCEAN_API_KEY=...
• A spreadsheet with one row per vendor and the columns from Step 5.

Step 1: Find out who answers on your plan

The support channel depends on the plan, so read it before you test anything. Support on a free plan is often docs only.

On LeadOcean, per the pricing page (October 2026): Solo ($97 a month) and Agency ($497 a month) get email support. Platform ($1,997 a month) adds a private Slack channel and an uptime SLA. Free lists docs only, so test it with the docs and the error bodies.

Write the answer down per vendor, for the plan you would actually buy:

vendor | plan you would buy | channel | named SLA? | status page?

A vendor with no channel listed for your plan has answered the question.

Step 2: Read your account state

A good API tells you where you stand without a ticket. Call the free account and usage endpoints.

curl -s https://api.leadocean.io/v1/account \
  -H "x-api-key: $LEADOCEAN_API_KEY" | jq .

curl -s https://api.leadocean.io/v1/usage \
  -H "x-api-key: $LEADOCEAN_API_KEY" | jq .

Score the vendor on one thing: can you answer "how many records are left and when does my limit reset" from the API alone? If you need a support ticket for that, mark it down.

Step 3: Trigger the documented errors on purpose

Send three requests that should fail, and read each body. A vendor that explains the failure saves you a ticket.

echo 'case 1: 401, wrong key'
curl -si https://api.leadocean.io/v1/people/search \
  -H "x-api-key: wrong_key" -H "Content-Type: application/json" \
  -d '{"title":["VP Sales"],"limit":1}'

echo 'case 2: bad enum value, jobLevel is an exact string'
curl -si https://api.leadocean.io/v1/people/search \
  -H "x-api-key: $LEADOCEAN_API_KEY" -H "Content-Type: application/json" \
  -d '{"jobLevel":["vice president"],"limit":1}'

echo 'case 3: 429, burst above the plan rate limit (5 a second on Free)'
for i in $(seq 1 20); do
  curl -s -o /dev/null -w "%{http_code}\n" https://api.leadocean.io/v1/account \
    -H "x-api-key: $LEADOCEAN_API_KEY" &
done; wait

Check four things in each response. Is the status code right? Does the body name the field that failed? Does a 429 carry Retry-After? Does the message say what to do next? Rate limits on LeadOcean are per plan: 5 requests a second on Free, 200 on Agency.

Step 4: File a real ticket and start a clock

Ask a question the docs answer badly. Then time the reply. Pick one that needs a human, not a link to the FAQ.

A good test ticket for a data vendor:

Subject: How is a catch-all email counted in your fair-use pace?

I am sizing a 50,000-row export. Does a catch_all address count the same as
a verified one? Where in the docs is this stated? I am on the [plan] plan.

Record four things. Note the time sent and the time of the first reply. Note whether a human or a canned answer replied. Note whether it answered the question. Send the same ticket to every vendor on the same weekday morning, so the clock is fair.

Step 5: Score it

Put the results in one table and weight what you care about. A free key is enough to fill every column except the paid-plan channel.

Do not average these into one number. Weight the rows by who will use the data. A vendor with great error bodies and a five-day ticket reply is a fit for engineers and a poor fit for a team that needs hand-holding.

Step 6: Read the docs as a support channel

Open the vendor's API reference and look for three things. Is there an OpenAPI file you can import? Does each endpoint list its error codes? Is there a changelog with dates? LeadOcean publishes its spec at api.leadocean.io/openapi.json.

Docs that answer the question before you ask it are the cheapest support a vendor can give. Count how many of your Step 3 errors you could have predicted from the docs alone. If the answer is none, expect to file tickets.

Step 7: Check support on the data itself

Support also means what the vendor does when a record is wrong. Ask each vendor in writing: if an email bounces, is there a refund or credit?

LeadOcean's policy: no refund or credit-back for bounced emails, so read email_status before you send. Then check that the vendor documents its filter values, so a bad value is your fault and not a mystery. Pull the list of filters for free:

curl -s https://api.leadocean.io/v1/filters \
  -H "x-api-key: $LEADOCEAN_API_KEY" | jq '.data.filters | length'
curl -s https://api.leadocean.io/v1/enums \
  -H "x-api-key: $LEADOCEAN_API_KEY" | jq -r '.data.enums[:5][].name'

Self-serve answers are support too. A vendor that lists every valid filter value removes most of the tickets you would otherwise file.

A vendor that states its bounce policy up front scores higher than one that answers only after a complaint.

Step 8: Read the results

Three patterns come up again and again. Learn to spot them.

The first is the fast ticket and weak errors. The vendor answers in an hour but returns a bare 400 with no field name. You will file many tickets, and each costs you time. This suits a team with an account manager and a budget for hand-holding.

The second is strong errors and a slow ticket. The API explains itself, so you rarely need help. A two-day reply matters less here. This suits engineers who read docs first.

The third is a missing channel. The plan you would buy lists no support at all. Treat that as a price, not a bug: you are buying data with no help attached.

LeadOcean publishes its OpenAPI file, and email support starts on Solo. Run the same test on us and judge the error bodies yourself.

What you get

A completed table and a ranked shortlist. To see what a free, well-formed answer looks like, here is the MCP tool leadocean_count_leads, run 2026-10-21 for US VPs in Customer/Client Service. It is a mailable count (verified, catch_all_valid or catch_all).

{
  "total": 7122,
  "totalIsExact": true,
  "totalAll": 14139,
  "distinctCompanies": 4084,
  "credits": 0,
  "unsupportedFilters": []
}

The count spent 0 records. It is a mailable count: 7,122 of 14,139 matching people have an email worth sending to.

Response shape from the API reference for a rate-limited call, with placeholder values:

HTTP/1.1 429 Too Many Requests
Retry-After: 1
X-RateLimit-Limit: 5

{"success": false, "error": {"message": "..."}}

Every response also carries X-RateLimit-Limit and X-Quota-State headers, which is the account state without a ticket.

Troubleshooting

FAQ