> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hasdata.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Yellow Pages Scraper

Power lead generation, local SEO research, and territory market mapping. Returns business title, URL, full address (country, region, city, zipcode, coordinates), phone, email, categories, working hours, payment options, amenities, website, menu link, rating + reviews, Tripadvisor rating + reviews, images, and breadcrumbs.

This scraper job is asynchronous. You'll receive a `jobId`, and can fetch results via polling or webhook delivery.

## Request Cost

Each row of data returned consumes **3 credits** from your balance.

<Tip>Credits are deducted only for successful rows.</Tip>

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://api.hasdata.com/scrapers/yellow-pages/jobs' \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <your-api-key>' \
    --data '{"limit":100,"keyword":"Pizza","locations":[],"sort":"name"}'
  ```

  ```javascript Node.js theme={null}
  const axios = require('axios').default;

  const options = {
    method: 'POST',
    url: 'https://api.hasdata.com/scrapers/yellow-pages/jobs',
    headers: {'Content-Type': 'application/json', 'x-api-key': '<your-api-key>'},
    data: {limit: 100, keyword: 'Pizza', locations: [], sort: 'name'}
  };

  try {
    const { data } = await axios.request(options);
    console.log(data);
  } catch (error) {
    console.error(error);
  }
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.hasdata.com/scrapers/yellow-pages/jobs"

  payload = {
      "limit": 100,
      "keyword": "Pizza",
      "locations": [],
      "sort": "name"
  }
  headers = {
      "Content-Type": "application/json",
      "x-api-key": "<your-api-key>"
  }

  response = requests.post(url, json=payload, headers=headers)

  print(response.json())
  ```

  ```php PHP theme={null}
  <?php

  $payload = [
      "limit" => 100,
      "keyword" => "Pizza",
      "locations" => [],
      "sort" => "name",
  ];

  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.hasdata.com/scrapers/yellow-pages/jobs",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_HTTPHEADER => [
      "Content-Type: application/json",
      "x-api-key: <your-api-key>",
    ],
  ]);

  $response = curl_exec($curl);
  curl_close($curl);

  echo $response;
  ```

  ```java Java theme={null}
  OkHttpClient client = new OkHttpClient();

  MediaType mediaType = MediaType.parse("application/json");
  String json = """
    {
      "limit": 100,
      "keyword": "Pizza",
      "locations": [],
      "sort": "name"
    }
  """;
  RequestBody requestBody = RequestBody.create(json, mediaType);

  Request request = new Request.Builder()
    .url("https://api.hasdata.com/scrapers/yellow-pages/jobs")
    .post(requestBody)
    .addHeader("Content-Type", "application/json")
    .addHeader("x-api-key", "<your-api-key>")
    .build();

  Response response = client.newCall(request).execute();
  ```

  ```csharp C# theme={null}
  using System.Net.Http;
  using System.Text;

  var client = new HttpClient();

  var json = """
  {
    "limit": 100,
    "keyword": "Pizza",
    "locations": [],
    "sort": "name"
  }
  """;
  var content = new StringContent(json, Encoding.UTF8, "application/json");

  var request = new HttpRequestMessage(new HttpMethod("POST"), "https://api.hasdata.com/scrapers/yellow-pages/jobs")
  {
      Content = content,
  };
  request.Headers.Add("x-api-key", "<your-api-key>");

  using var response = await client.SendAsync(request);
  response.EnsureSuccessStatusCode();
  var body = await response.Content.ReadAsStringAsync();
  Console.WriteLine(body);
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'
  require 'json'

  uri = URI("https://api.hasdata.com/scrapers/yellow-pages/jobs")
  payload = {
    "limit" => 100,
    "keyword" => "Pizza",
    "locations" => [],
    "sort" => "name",
  }

  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(uri)
  request["Content-Type"] = 'application/json'
  request["x-api-key"] = '<your-api-key>'
  request.body = payload.to_json

  response = http.request(request)
  puts response.read_body
  ```

  ```rust Rust theme={null}
  use reqwest::blocking::Client;
  use serde_json::json;

  fn main() -> Result<(), Box<dyn std::error::Error>> {
      let client = Client::new();
      let payload = json!({
          "limit": 100,
          "keyword": "Pizza",
          "locations": [],
          "sort": "name"
      });
      let res = client
          .post("https://api.hasdata.com/scrapers/yellow-pages/jobs")
          .header("Content-Type", "application/json")
          .header("x-api-key", "<your-api-key>")
          .json(&payload)
          .send()?
          .text()?;
      println!("{}", res);
      Ok(())
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"bytes"
  	"fmt"
  	"io"
  	"net/http"
  )

  func main() {
  	payload := []byte(`{
    "limit": 100,
    "keyword": "Pizza",
    "locations": [],
    "sort": "name"
  }`)

  	req, _ := http.NewRequest("POST", "https://api.hasdata.com/scrapers/yellow-pages/jobs", bytes.NewBuffer(payload))
  	req.Header.Add("Content-Type", "application/json")
  	req.Header.Add("x-api-key", "<your-api-key>")

  	res, _ := http.DefaultClient.Do(req)
  	defer res.Body.Close()

  	responseBody, _ := io.ReadAll(res.Body)
  	fmt.Println(string(responseBody))
  }
  ```
</CodeGroup>

## Job Parameters

<ParamField body="limit" type="number" required>
  Data limit (0 - unlimited)
</ParamField>

<ParamField body="keyword" type="string" required>
  Search query for YellowPages businesses to scrape
</ParamField>

<ParamField body="locations" type="string" required>
  Location to search for businesses using a specific keyword. Use predefined Country–State pairs, or enter your own locations — one per line (supported by YellowPages).
</ParamField>

<ParamField body="sort" type="string" required>
  Sort By
</ParamField>

## Supported Enrichments

Request any of the fields below via the `enrichments` array in your job payload.

| ID             | Title               | Description                    | Cost per Request |
| -------------- | ------------------- | ------------------------------ | ---------------- |
| `email`        | Email Address       | Business email address         | 5 credits        |
| `website`      | Website URL         | Business website URL           | 5 credits        |
| `phone`        | Phone Number        | Business phone number          | 5 credits        |
| `linkedinUrl`  | LinkedIn Profile    | Business LinkedIn page URL     | 5 credits        |
| `facebookUrl`  | Facebook Profile    | Business Facebook page URL     | 5 credits        |
| `instagramUrl` | Instagram Profile   | Business Instagram profile URL | 5 credits        |
| `xUrl`         | X (Twitter) Profile | Business X profile URL         | 5 credits        |
| `revenue`      | Revenue             | Business revenue               | 5 credits        |
| `traffic`      | Website Traffic     | Business website traffic       | 5 credits        |
| `funding`      | Funding Info        | Business funding information   | 5 credits        |
| `founded`      | Founded Year        | Business founded year          | 5 credits        |

## Getting Results

<Card title="Webhooks" horizontal icon="webhook" href="/scrapers/webhooks">
  Receive real-time updates when your scraper job starts, completes, or collects data.
</Card>

<Card title="Results API" horizontal icon="list" href="/scrapers/getting-results">
  Use the Results API to fetch your data using the `jobId`, with support for polling and pagination.
</Card>

<Card title="Stopping a Job" horizontal icon="circle-stop" href="/scrapers/stopping-job">
  Cancel an active scraper job early if it's no longer needed or you want to save credits.
</Card>