Google Maps scraper API: pull business listings from your own code

To pull Google Maps business records from your own code, create a bearer key under API keys in your Evascrape account, then use POST /quote to price a search and POST /jobs to start it. Google Maps searches take a search term and a place. Check the job through GET /jobs/{id} and retrieve its records through GET /jobs/{id}/results as JSON or CSV. Before writing the request body or importer, inspect https://evascrape.com/docs/openapi.json for the documented input properties and results schema. Treat the requested record count as a ceiling, not a delivery promise.

Google Maps scraper API fields: check the results schema before mapping records

Evascrape returns Google Maps business records as JSON through the public API and as a CSV file in the dashboard. The verified source does not specify the returned field names or establish where any email addresses are collected. Inspect the results schema for GET /jobs/{id}/results in https://evascrape.com/docs/openapi.json before defining your destination fields.

• Locate GET /jobs/{id}/results in the OpenAPI description and inspect its documented response schema.
• Map only confirmed response properties into your application. Do not create mappings based on assumed business-name, address, phone, website, rating or email property names.
• Check the documented data types and any rules for optional or missing properties before writing your importer.
• Inspect a returned response against the documented schema before processing it. Do not assume that JSON records arrive as a bare array or inside a property named results.
• Do not assume every delivered record has an email address. Delivered records without an email have a separate billing rate.

Keep the results format separate from the field mapping. Use the documented JSON structure for an application import, or download the CSV from the dashboard for a CRM or outreach-tool import. Evascrape has no native CRM integration, so the CSV is the supported file-based handoff.

Google Maps scraper API authentication: create a bearer key and check the request schema

Authenticate requests with a bearer key created in your Evascrape account under API keys. Send that key in the Authorization header to the base URL https://app.evascrape.com/api/v1. A balance check uses GET https://app.evascrape.com/api/v1/balance with the header Authorization: Bearer YOUR_API_KEY, replacing YOUR_API_KEY with your account key.

• Open API keys in your account and create a bearer key.
• Open the OpenAPI 3.1 description at https://evascrape.com/docs/openapi.json before constructing your Google Maps request body.
• Find POST /quote and POST /jobs in the description. Inspect each operation's request schema and check the documented property names, accepted values and data types.
• Locate the Google Maps input definition and confirm the exact properties for the search term and place. Do not assume that form labels are also JSON keys.

For an example search, prepare “dentists” as the search term and “Berlin, Germany” as the place, then map those values to the documented request properties. Google Maps also accepts optional language, minimum rating, categories and skipping permanently closed places. Check their representations in the schema before adding them to your request.

Google Maps scraper API Python example: quote, start a job, poll status and retrieve results

The Python workflow uses POST /quote to price the job, POST /jobs to start it, GET /jobs/{id} to check status and GET /jobs/{id}/results to retrieve records. Prepare a Google Maps search for “dentists” in “Berlin, Germany” with a requested count of 100. The verified source establishes these endpoints but not their exact request properties, response envelopes or format-selection mechanism. The script therefore requires those details to be supplied from the OpenAPI description.

• Install the Python requests package and set EVASCRAPE_API_KEY to the bearer key created under API keys in your account.
• Using https://evascrape.com/docs/openapi.json, prepare quote-request.json and job-request.json for the same Google Maps search and requested count. Follow each endpoint's request schema rather than assuming the bodies are identical.
• Set EVASCRAPE_JOB_ID_PATH and EVASCRAPE_STATUS_PATH to JSON-encoded lists of property names locating the job identifier in the start response and the status in the status response. Use the documented response structures, not guessed property names.
• Prepare results-request.json with headers and params objects containing only the documented headers or query parameters needed to select JSON results. Leave an object empty if that part is not required by the documented contract. This file configures the Python request; it is not an Evascrape request-body schema.
• Set EVASCRAPE_POLL_SECONDS to your chosen polling interval. Stay within 120 requests per minute per key and 20 job starts per minute, accounting for other processes using the same key.

Run the script after preparing the files and environment variables. It prints the quote and waits for confirmation before starting the paid job. The loop waits while the job is queued or running, retrieves results after succeeded, and stops without requesting results after failed or no_results. ```python import json import os import time from pathlib import Path import requests BASE = "https://app.evascrape.com/api/v1" session = requests.Session() session.headers.update({ "Authorization": f"Bearer {os.environ['EVASCRAPE_API_KEY']}" }) def read_json(filename): return json.loads(Path(filename).read_text()) def extract(document, path): for property_name in path: document = document[property_name] return document def request_json(method, path, **kwargs): response = session.request(method, BASE + path, **kwargs) response.raise_for_status() return response.json() id_path = json.loads(os.environ["EVASCRAPE_JOB_ID_PATH"]) status_path = json.loads(os.environ["EVASCRAPE_STATUS_PATH"]) poll_seconds = float(os.environ["EVASCRAPE_POLL_SECONDS"]) quote_payload = read_json("quote-request.json") job_payload = read_json("job-request.json") results_options = read_json("results-request.json") quote = request_json("POST", "/quote", json=quote_payload) print("Quote:", json.dumps(quote)) if input("Start this paid job? Type yes: ").strip().lower() != "yes": raise SystemExit("Job not started.") started = request_json("POST", "/jobs", json=job_payload) job_id = extract(started, id_path) print("Save this job ID:", job_id) while True: job = request_json("GET", f"/jobs/{job_id}") status = extract(job, status_path) print("Status:", status) if status in {"queued", "running"}: time.sleep(poll_seconds) continue if status == "succeeded": break if status == "failed": print("Job response:", json.dumps(job)) raise SystemExit("Job failed. No results retrieval attempted.") if status == "no_results": print("Job response:", json.dumps(job)) raise SystemExit("Job returned no results.") raise RuntimeError(f"Unexpected job status: {status}") results = request_json( "GET", f"/jobs/{job_id}/results", headers=results_options["headers"], params=results_options["params"], ) Path("businesses.json").write_text(json.dumps(results)) print("JSON response saved to businesses.json") ``` The saved file contains the returned JSON response. The script does not assume a bare array, a particular record schema or pagination behavior. Check the results contract before treating the saved response as the complete export. If execution stops after submission, use the printed job ID to resume status checks rather than submitting another paid job.

Google Maps scraper API job states: queued, running, succeeded, failed and no_results

Read the job status through GET /jobs/{id} and handle the documented values explicitly: queued, running, succeeded, failed and no_results. Keep status checks separate from result retrieval so the importer does not request an export while the job is still running.

• queued: Keep the existing job ID and schedule another status check. Do not submit a replacement job just because this job has not started running.
• running: Continue checking the existing job. Keep this branch separate from the results request.
• succeeded: Stop polling and request GET /jobs/{id}/results using the documented retrieval contract.
• failed: Stop polling and preserve the job ID and returned response for investigation instead of automatically starting another paid job.
• no_results: Stop polling and record this outcome separately from failed.

In Python, use `status in ('queued', 'running')` for the waiting branch and `status == 'succeeded'` for the retrieval branch. Give failed and no_results separate branches, then stop normal processing if an unexpected value appears. Keep an HTTP request error separate from a returned job status in your application's error handling.

Google Maps scraper API pagination and CSV exports: check the results contract

Check GET /jobs/{id}/results in https://evascrape.com/docs/openapi.json before writing a pagination loop. The verified source establishes JSON and CSV retrieval but does not establish pagination parameters, continuation fields or a response envelope. Do not assume that page, offset or cursor parameters are supported.

• Find GET /jobs/{id}/results in the OpenAPI description. Inspect its documented query parameters, response schema and method for selecting JSON or CSV.
• Make a results request with an actual job ID and compare the response with the documented schema before mapping records.
• Implement a page loop only if the documented contract specifies pagination. Use its documented continuation mechanism and stopping condition.
• If pagination behavior is not established by the documentation, do not add guessed parameters or repeat requests around an assumed next-page field.

Use CSV when the next step is an import into a CRM or outreach tool. Download the CSV from the dashboard, or retrieve CSV through GET /jobs/{id}/results using the documented format-selection method. Use JSON when your code will process the records directly. Evascrape has no native CRM integration and no browser extension.

Google Maps scraper API pricing and limits: requested counts, search terms and refunds

Google Maps business records cost 12 US dollars per 1,000 records. The requested count is a ceiling, not a delivery promise. Each job accepts a minimum of 100 records and a maximum of 50,000, in multiples of 100. Fewer matching records mean a smaller file and a smaller bill.

Google Maps collects up to 500 places per search term, so a larger total needs more search terms. Requesting 1,000 records does not make a search term return more than 500 places. The Google Maps job form states how many search terms are needed before any money is spent. In an API workflow, check the documented input schema before supplying the search terms.

Call POST /quote to price the job for free before calling POST /jobs. When the job starts, Evascrape charges the prepaid US-dollar balance at the requested record count. When the job finishes, the undelivered portion is refunded automatically. For reconciliation, credits_charged plus credits_refunded always equals the amount reserved.

Delivered records without an email address are billed at 6 US dollars per 1,000 instead of the full rate. Optional real-time email verification costs an additional 5 US dollars per 1,000 and is never included in the base price. With that add-on, the export is split into good, risky and bad email files. Billing uses a single prepaid balance, with no subscription or per-seat fee, and credits do not expire. Check the balance through GET /balance.

Google Maps scraper API callbacks: callback_url and HMAC-SHA256

Use the optional callback_url when your application will receive the finished job at a callback endpoint. Evascrape signs the callback with HMAC-SHA256. Otherwise, check the job through GET /jobs/{id}, keeping requests within 120 per minute per key.

The verified source does not specify the signature header, signing secret, signed content, encoding, acknowledgement requirements or retry behavior. Check https://evascrape.com/docs/openapi.json before implementing the callback receiver. Do not invent those details or assume the bearer API key is the signing secret.

• Check the documented placement and representation of callback_url before adding it to the job request.
• Implement signature verification only against an established signing contract. The algorithm alone does not specify how to verify the notification.
• If the documentation does not establish the verification details, keep the workflow on status polling rather than processing unverified notifications.
• Use GET /jobs/{id}/results for JSON or CSV retrieval; do not assume a callback contains the exported records.

Google Maps business data compliance and removal requests

Evascrape collects only publicly available business data, never private messages or login-protected content. The service is aligned with GDPR and CCPA. Data-removal requests go through https://evascrape.com/compliance.

• Use https://evascrape.com/compliance to submit a removal request.
• Do not describe the export as including private messages or login-protected content.
• Do not infer where email addresses were collected from the availability of an email in a delivered record. The verified source does not establish email provenance.

The public-data collection scope does not establish whether scraping a particular platform is permitted or prohibited. Refer to https://evascrape.com/compliance for Evascrape's compliance information rather than making a platform-permission claim.