I Ran the Numbers on Google Maps Place Details. Here’s When to Use Them

Abstract illustration of the shortlist decision. The article tables hold the exact prices and field rules.

Short answer: If you need rich details for only a handful of businesses from a Maps search, get the ranked list first and look up just those places. At Serpent's published Default rates, one 100-place List call plus nine selected Place Details calls is $0.014. A standard Deep call is $0.015 and requests enrichment for up to the first 20 ranked places. At ten selected lookups, List plus Place costs $0.0155. The outputs differ: Deep may be the cheaper call while enriching the wrong businesses for your job.

I am Serpent API's founder, so I have a stake in this comparison. I worked through our published call prices and the other providers' public terms to answer a narrower question than “which Maps API is cheapest?”: when should you pay for details on a shortlist instead of the top results? A cheap list row is not a rich business record, and a request for 20 details may complete fewer. For a broader provider price survey, use our Google Maps API pricing comparison.

What you actually buy with each Maps call

The three calls in this decision do different jobs. List discovers ranked core records. Place Details opens one selected business. Deep combines discovery with enrichment of the first requested number of ranked results. The public Maps reference defines their parameters and result fields.

The default for /api/maps/search is detail=20, which is Deep. You must send detail=0 to buy List. On a List call, omitting limit asks for 20 places, not 100. The published rates above are billed per call, not per place returned. If a search finds 37 businesses after you ask for 100, the call is still the 100-place List price band; your cost per actual record is different. See the Maps product page for the supported operations.

First decide what the record must contain

Ask a practical question before comparing cents: would a ranked row answer the job? For a local rank report, a name, rank, category, address, coordinates, rating, review count, phone, and website from a core row may be enough. If your team needs structured hours, images, amenities, booking links, or a status that confirms enrichment finished, plan a Place or Deep call. Our place field reference identifies which properties are nullable and which empty collections mean the source supplied no data.

A useful distinction: detail_status="complete" means the detail stage finished; it does not mean Google exposes every property you wish it did. opening_hours={} or popular_times={} is a missing source value, not a reason to fill in a guess. If popularity is central to the task, read our Popular Times availability guide before pricing a full roll-out.

The Selective Enrichment Break-Even Point

For a 100-place discovery call at the published Default rate, the planned charge is $0.0005 + ($0.0015 × selected places). One standard Deep call is $0.015. The table holds the discovery request fixed and varies only how many selected businesses get individual detail lookups. It compares call charges, not the number of records that pass your quality rule.

Calculation: published Serpent Default prices read October 1, 2026; one List call with detail=0&limit=100; one Place Details call for each selected business; one Deep call with detail=20. These are planned-charge examples, not observed invoices, returned counts, or throughput measurements.

The ranking changes the decision: Deep targets the first 20 ranked businesses. Selective lookups can target businesses you recognize anywhere in the discovered list. If you need five specific places ranked 60–90, the $0.008 selective path can answer your question while standard Deep may enrich none of those five. If you need all of the top 20, the $0.015 Deep path is cheaper on published prices and requires fewer calls. Neither price says how many required fields will be present.

A smaller List 20 call changes the equation to $0.0001 + $0.0015 × selected. Nine Place calls total $0.0136; ten total $0.0151. The break remains between nine and ten. At the published Growth and Scale tier rates, the same proportional discounts apply to List, Place, and Deep, so the break remains at the same count. Your deposit-based price tier and current-balance request allowance are separate account settings; the pricing page explains both.

Arithmetic from the published Serpent table, October 1, 2026: List 100 is $0.50/$0.45/$0.35 per 1,000 calls, Place is $1.50/$1.35/$1.05 per 1,000, and standard Deep is $15/$13.50/$10.50 per 1,000 at Default/Growth/Scale respectively. Excludes credits, tax, and any change to billing terms.

I would not choose between a ninth and tenth detail call on half a cent alone. If your shortlist changes frequently, count the extra requests, the time to complete them, and whether the fields you need actually appear. A completed rich record can still lack a phone, website, or hours field; our place-details field audit shows why your storage schema must allow that.

Calculate Cost per Usable Record, Not per Requested Record

Decide what usable means before pricing a campaign. For a directory refresh, you might require a name, a stable identifier, and either a phone or website. For an hours audit, you may require a non-empty opening_hours object. Those are your business rules, not promises that every source page contains the field.

Use this equation after the run: actual billable spend ÷ records that meet your required-field rule. If a $0.008 planned List-plus-five-Place run produces only four usable records, your effective cost is $0.002 per usable record. If it produces three, the effective cost is about $0.00267. Those two outcomes are illustrations of the denominator, not coverage data.

For Deep, do not divide $0.015 by 20 by default. Read counts.fully_enriched and each place's detail_status. The Maps response contract keeps core records when detail is incomplete, and a returned place with detail_status="core_only" is not a completed enrichment. A fully enriched place can still lack your required business field; treat that as a second check.

Keep three denominators in your report

1. Discovered: places in the ranked list. This tells you how much search coverage you got, not how much enrichment you bought.
2. Completed detail: selected or Deep places whose detail_status is complete. This separates deadline-limited records from finished lookups.
3. Usable: completed records meeting your explicit field rule. This is the denominator for a lead list, opening-hours audit, or another downstream task.

Log the query, location, country, timestamp, selected IDs, requested detail count, returned counts, and billable charges beside those denominators. Deduplicate by stable place identifier before reporting unique businesses across neighboring searches. A business can appear in two nearby search areas; counting it twice makes cost per unique usable place look artificially low. If you make additional calls to fill gaps, include those calls in the numerator. If no record qualifies, report the usable count as zero and cost per usable record as undefined rather than dividing by zero.

Here is another transparent illustration: suppose a $0.015 Deep call returns 18 completed details and 14 of those include every field your team requires. The effective cost is about $0.00107 per usable record. If the same call yields five usable records, it is $0.003. Those are hypothetical outcomes showing the math, not measured Serpent field coverage.

A Complete Selective Lookup Example

Here is a small Node.js 18+ example. It discovers up to 100 places, chooses five records as a placeholder shortlist, opens each one sequentially, and counts completed records with a name, identifier, and a phone or website. Replace the shortlist rule with your own known-business or rank rule. Sequential requests keep the example within an account that has a low concurrency allocation.

// Node.js 18+; set SERPENT_API_KEY in your environment.
const base = 'https://apiserpent.com';
const key = process.env.SERPENT_API_KEY;
if (!key) throw new Error('Set SERPENT_API_KEY before running this script');

async function read(path, params) {
  const url = new URL(path, base);
  for (const [name, value] of Object.entries(params)) url.searchParams.set(name, value);
  const response = await fetch(url, { headers: { 'X-API-Key': key } });
  const body = await response.json();
  if (!response.ok || body.success !== true) {
    throw new Error(`Request failed with HTTP ${response.status}`);
  }
  return body;
}

async function main() {
  const list = await read('/api/maps/search', {
    q: 'dentist', location: 'Austin, TX', country: 'us', detail: '0', limit: '100'
  });
  if (!Array.isArray(list.places)) throw new Error('No parsed place list returned');

  // Demo shortlist: first five identified places. Use your own selection rule.
  const selected = list.places.filter(place => place.place_id || place.data_id).slice(0, 5);
  const detailRecords = [];
  for (const item of selected) {
    try {
      const identifier = item.place_id ? { place_id: item.place_id } : { data_id: item.data_id };
      const result = await read('/api/maps/place', identifier);
      if (result.place && (result.place.place_id || result.place.data_id)) detailRecords.push(result.place);
    } catch (error) {
      // Keep the records already collected; a failed lookup is not a usable record.
      console.error(`Could not read ${item.place_id || item.data_id}: ${error.message}`);
    }
  }
  const usable = detailRecords.filter(place =>
    place.detail_status === 'complete' && place.name &&
    (place.place_id || place.data_id) && (place.phone || place.website)
  );
  console.log({ discovered: list.places.length,
    selected: selected.length, detailRecords: detailRecords.length,
    usable: usable.length });
}
main().catch(error => { console.error(error.message); process.exitCode = 1; });

The output is a count object such as { discovered: 37, selected: 5, detailRecords: 5, usable: 4 } when those values happen to come back. That line is an illustrative shape, not a measured result. An empty list can be a valid response; a returned core record is never promoted to a rich record in this script. Check actual billing in your account: unsuccessful calls, free credits, and plan discounts can change the amount charged.

If you are looking for businesses without a website, absence in a core row should be a candidate signal, not proof. Open the selected place and check the detail value before classifying it; our no-website workflow explains the reporting use case. For contact outreach, the Maps-to-email guide covers the extra validation steps after discovery.

Can You Run This Schedule Within the Published Limits?

One List call and five Place calls are six account requests. At a schedule of 100 such batches per day, that is 600 requests/day: 100 List calls, at most 500 selected Place calls, and $0.80 in planned Default charges at the published prices. Spread evenly across 24 hours, that is 25 requests/hour on average. It is arithmetic, not a throughput test; bursts and completion times still matter.

The published rate-limit table shows a free-bracket standard allocation of 500/day, so that particular 600/day schedule does not fit the free bracket. A Default balance below $100 has a published standard allocation up to 10,000/day, 1,000/hour, 100/minute, and 10 concurrent requests, so the 600/day schedule fits with room to spare. The numbers are ceilings, not a service-level guarantee. Your live balance can change your limit bracket, while your one-time deposit locks the price tier separately. Read your own current limits from GET /api/status before you queue work, and keep the requests spread through the day.

If you need details for more than the first 20 businesses, the Deep premium band is a different decision: the current price table lists $0.075 per call for detail 21–100 at Default, and a synchronous request is capped at 30 details. Above that, check your account's job availability in /api/status before designing the run. Do not assume that a 100-result List call, 100 individual Place calls, and a 100-detail job have equal response time or field coverage.

Monthly translation: 100 batches daily for 30 days at List 100 plus five selected details equals 3,000 List calls and at most 15,000 Place calls, or 18,000 requests and $24 planned Default spend before credits and tax. That is $0.80 a day, and it requires at most 600 requests on each day. Schedule against daily, hourly, and minute limits, not only the monthly total. If five lookups per batch routinely yield only four usable businesses, the illustrative monthly denominator is 12,000, making the effective price $0.002 per usable record. Change the denominator to your observed count after QA.

How the Other Google Maps Data Providers Charge

A shortlist workflow does not make Serpent the right product for every team. I compared the published billing units and task fit of six other providers using their own documentation and price pages read on October 1, 2026; Google's price and field-SKU references were checked again October 5. This is a documentation comparison. Result counts, fields, turnaround, free allowances, and billable events differ, so the table does not invent one universal “cost per enriched place.”

Public prices as read October 1, 2026, in USD; Google SKU figures rechecked October 5. Google's numbers are global pay-as-you-go list prices, not an India price or a final quote. Free usage, account terms, field masks, request methods, freshness, output rights, and tax differ. No cross-provider latency or completeness benchmark was run.

What a fair comparison changes

Google's official API is the direct route when its contract matters. Text Search (New) requires a field mask, returns up to 20 places per page and currently caps a query at 60 across pages. Asking for displayName moves search to Pro; asking for a phone or website can move it to Enterprise. A Place Details request can be Essentials or Pro depending on its requested fields, and a higher SKU may apply. Request the fields your task needs in Text Search when available; adding a Details charge to every Google search would overstate its cost. Google's free usage caps and subscription plans can change the economics. Its Places policies and attribution rules should be part of the product decision, especially if you store or display the data.

DataForSEO is strong for queued SERP collection. Its Standard Maps page at $0.0006 is close to Serpent's $0.0005 List 100 call, and its Live page is $0.002. That is a comparison of search pages, not rich detail records. DataForSEO documents a task workflow, result depth, and parameters that can multiply cost. If you already use its queue and can wait, the integration may matter more than a tenth of a cent; if you need one immediate ranked list plus a few selected rich records, model the added detail work first.

Record-billed vendors solve a different procurement problem. Outscraper, Apify Compass, and Bright Data can be attractive when you want thousands of business rows or files, especially while a free allowance applies. A paid record is not automatically a record meeting your phone, website, or hours rule. Ask whether duplicates, missing fields, optional enrichments, and failed rows count toward the invoice. Apify Compass says direct Place IDs and URLs trigger a paid additional-details add-on, so include that cost before comparing a known-place refresh. For SerpApi, the monthly subscription buys a search allowance and hourly capacity; six requests from a search-plus-five-place workflow use a different portion of that allowance than one search. Our own broader provider survey covers more procurement scenarios.

Serpent's documented fit here is control over the enrichment decision: a $0.0005 List 100 call provides the shortlist, then $0.0015 Place calls target the IDs you choose. That matters when the businesses you need are sparse or far down the ranking. It does not establish the lowest cost for every field set or workload. Run a small, permitted sample with each finalist, apply the same usable-record rule, and compare returned fields and actual charges before committing to a larger schedule.

What the price sheet cannot tell you

A provider can quote a low search price while returning many irrelevant or duplicate businesses for your geography. Another can charge more per row yet deliver the specific fields your team needs. For each option, record geographic relevance, unique place IDs, required-field completion, turnaround, and data-use terms. Keep the original query and selection rule with that audit. Those observations give a better procurement answer than dividing one advertised price by an assumed result count.

A Practical Decision Rule

1. Name your required fields. A list row may already answer a rank question. A detail-dependent task needs a richer call.
2. Decide which businesses matter. If they are a sparse shortlist from anywhere in 100 results, start with List and selected Place lookups.
3. Count expected detail lookups. At published Default prices, up to nine selected lookups plus List 100 are below one standard Deep call. At ten, Deep is cheaper on the call total, provided the first 20 are the businesses you actually need.
4. Check completeness after the response. Report discovered, fully enriched, and usable records separately. Do not turn a missing field into a claimed fact.
5. Check the live limits and bill. Price tier, free credits, live-balance limit bracket, and partial results affect the real unit cost.

Trial worksheet: choose one query and exact geographic scope, write down the same five mandatory fields for each provider, run enough allowed calls to inspect their output shapes, then record: searches billed, detail calls billed, discovered rows, unique IDs, fully completed details, usable rows, elapsed time, and total charge. Divide spend by usable unique rows. Record the provider's data-use terms beside that figure. A plan with a low headline price can still be poor value when your specific required field is sparse; a higher list price can make sense when its data and delivery fit the job.

The Maps playground lets you inspect one query before you put a shortlist rule into code. Save the returned counts and check the fields against your own usable-record rule; then price the calls with your current account tier.

FAQ

When does Maps List plus selected Place Details cost less than Maps Deep?

At published Default prices on October 1, 2026, one 100-place List call plus up to nine selected Place calls costs less than one standard $0.015 Deep call: $0.014 at nine. Ten selected calls cost $0.0155. Deep enriches the first 20 ranked results; selected lookups can target different records.

Does a Maps List result count as an enriched business record?

No. List returns ranked core records only. Count a record as usable enriched data only after the detail call gives you the fields and completion state your task requires.

Does Maps Deep enrich all 100 returned places?

No. It returns up to 100 ranked places, but at detail=20 it requests enrichment for up to the first 20. Inspect counts.fully_enriched and each detail_status; some may remain core-only.

What if a selected place has no phone number or website?

Keep the record with the missing field marked as unavailable. A completed lookup does not guarantee every public field exists. Exclude it from the denominator only if your stated usable-record rule needs that field.

Are the table values a measured API benchmark?

No. They are arithmetic using published per-call prices read October 1, 2026. They do not claim a measured return rate, response time, throughput, or final bill.

Sources

• Serpent public pricing and rate limits, read October 1, 2026.
• Serpent public Maps request and response documentation, read October 1, 2026.
• Google Places Text Search documentation.
• Google Places Place Details documentation.
• Google Maps Platform official pricing table and field SKU reference, rechecked October 5, 2026.
• DataForSEO Maps SERP pricing; SerpApi plans and Maps Place documentation.
• Outscraper pricing, Apify Compass Google Maps Scraper listing, and Bright Data Maps Scraper API pricing.