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

# Examples - Person Search API

# Examples

We've provided code samples in Python, cURL, Ruby, Go and JavaScript. If you aren't comfortable working in any of these languages, feel free to use this [handy tool](https://curlconverter.com/) to convert code from cURL to the language of your choice.

<Danger>
  **Heads Up! Credit Usage**

  Person Search API calls cost the number of **total search results** returned.

  If you are making a search that could have a large number of results, make sure to use the [`size` parameter](/docs/input-parameters-person-search-api#size) to set the maximum number of results and cap your credit usage.
</Danger>

<Tip>
  **We want your feedback!**

  Do you see a bug? Is there an example you'd like to see that's not listed here?

  Head over to the public roadmap and submit a [bug ticket](https://peopledatalabs.canny.io/bugs) or a [feature request](https://peopledatalabs.canny.io/feature-requests) and receive automatic notifications as your bug is resolved or your request is implemented.
</Tip>

## Basic Usage

*"I want to make a query and save the results to a file."*

<CodeGroup>
  ```python Python3 SDK (Elasticsearch) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}},
              {"exists": {"field": "phone_numbers"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': ES_QUERY,
    'size': 10,
    'pretty': True
  }

  # Pass the parameters object to the Person Search API
  response = CLIENT.person.search(**PARAMS).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```python Python3 SDK (SQL) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE location_country='mexico'
    AND job_title_role='health'
    AND phone_numbers IS NOT NULL;
   """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 10,
    'pretty': True
  }

  # Pass the parameters object to the Person Search API
  response = CLIENT.person.search(**PARAMS).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```bash cURL theme={null}
  # Elasticsearch
  curl -X GET 'https://api.peopledatalabs.com/v5/person/search' \
  -H 'X-Api-Key: xxxx' \
  --data-raw '{
    "size": 10,
    "query": {
      "bool": {
        "must": [
          {"term": {"location_country": "mexico"}},
          {"term": {"job_title_role": "health"}},
          {"exists": {"field": "phone_numbers"}}
        ]
      }
    }
  }'

  # SQL
  curl -X GET \
    'https://api.peopledatalabs.com/v5/person/search' \
    -H 'X-Api-Key: xxxx' \
    --data-raw '{
      "size": 10,
      "sql": "SELECT * FROM person WHERE location_country='\''mexico'\'' AND job_title_role='\''health'\'' AND phone_numbers IS NOT NULL;"
  }'
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  import fs from 'fs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an Elasticsearch query
  const esQuery = {
    query: {
      bool: {
        must:[
          {term: {location_country: "mexico"}}, 
          {term: {job_title_role: "health"}}, 
          {exists: {field: "phone_numbers"}}
        ]
      }
    }
  }

  // Create a parameters JSON object
  const params = {
    searchQuery: esQuery, 
    size: 10,
    pretty: true
  }

  // Pass the parameters object to the Person Search API
  PDLJSClient.person.search.elastic(params).then((data) => {
      // Write out all profiles found to file
      fs.writeFile("my_pdl_search.jsonl", Buffer.from(JSON.stringify(data.data)), (err) => {
          if (err) throw err;
      });
      console.log(`Successfully grabbed ${data.data.length} records from PDL.`);
      console.log(`${data["total"]} total PDL records exist matching this query.`)
  }).catch((error) => {
      console.log("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
      console.log(error);
  });
  ```

  ```javascript JavaScript (SQL) theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  import fs from 'fs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an SQL query
  const sqlQuery = `SELECT * FROM person 
                    WHERE location_country='mexico' 
                    AND job_title_role='health'
                    AND phone_numbers IS NOT NULL;`

  // Create a parameters JSON object
  const params = {
    searchQuery: sqlQuery, 
    size: 10,
    pretty: true
  }

  // Pass the parameters object to the Person Search API
  PDLJSClient.person.search.sql(params).then((data) => {
      // Write out all profiles found to file
      fs.writeFile("my_pdl_search.jsonl", Buffer.from(JSON.stringify(data.data)), (err) => {
          if (err) throw err;
      });
      console.log(`Successfully grabbed ${data.data.length} records from PDL.`);
      console.log(`${data["total"]} total PDL records exist matching this query.`)
  }).catch((error) => {
      console.log("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
      console.log(error);
  });
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}},
              {"exists": {"field": "phone_numbers"}}
        ]
      }
    }
  }

  # Pass parameters to the Person Search API
  response = Peopledatalabs::Search.person(searchType: 'elastic', query: ES_QUERY, size: 10, pretty: true)

  # Check for successful response
  if response['status'] == 200
      data = response['data']
      # Write out each profile found to file
      File.open("my_pdl_search.jsonl", "w") do |out|
          data.each { |record| out.write(JSON.dump(record) + "\n") }
      end
      puts "Successfully grabbed #{data.length()} records from PDL."
      puts "#{response['total']} total PDL records exist matching this query."
  else
      puts "NOTE: The carrier pigeons lost motivation in flight. See error and try again."
      puts "Error: #{response}"
  end
  ```

  ```ruby Ruby (SQL) theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE location_country='mexico'
    AND job_title_role='health'
    AND phone_numbers IS NOT NULL;
   """

  # Pass parameters to the Person Search API
  response = Peopledatalabs::Search.person(searchType: 'sql', query: SQL_QUERY, size: 10, pretty: true)

  # Check for successful response
  if response['status'] == 200
      data = response['data']
      # Write out each profile found to file
      File.open("my_pdl_search.jsonl", "w") do |out|
          data.each { |record| out.write(JSON.dump(record) + "\n") }
      end
      puts "Successfully grabbed #{data.length()} records from PDL."
      puts "#{response['total']} total PDL records exist matching this query."
  else
      puts "NOTE: The carrier pigeons lost motivation in flight. See error and try again."
      puts "Error: #{response}"
  end
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "os"
      "encoding/json"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create an Elasticsearch query
      elasticSearchQuery := map[string]interface{} {
          "query": map[string]interface{} {
              "bool": map[string]interface{} {
                  "must": []map[string]interface{} {
                      {"term": map[string]interface{}{"location_country": "mexico"}},
                      {"term": map[string]interface{}{"job_title_role": "health"}},
                      {"exists": map[string]interface{}{"field": "phone_numbers"}},
                  },
              },
          },
      }

      // Create a parameters JSON object
      params := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 10,
              Pretty: true,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              Query: elasticSearchQuery,
          },
      }
      
      // Pass the parameters object to the Person Search API
      response, err := client.Person.Search(context.Background(), params)
      // Check for successful response
      if err == nil {
          data := response.Data
          // Create file
          out, outErr := os.Create("my_pdl_search.jsonl")
          defer out.Close()
          if (outErr == nil) {
              for i := range data {
                  // Convert each profile found to JSON
                  record, jsonErr := json.Marshal(data[i])
                  // Write out each profile to file
                  if (jsonErr == nil) {
                      out.WriteString(string(record) + "\n")
                  }
              }
              out.Sync()
          }
          fmt.Printf("Successfully grabbed %d records from PDL.\n", len(data))
          fmt.Printf("%d total PDL records exist matching this query.\n", response.Total)
      } else {
          fmt.Println("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
          fmt.Println("Error:", err)
      } 
  }
  ```

  ```go Go (SQL) expandable theme={null}
  package main

  import (
      "fmt"
      "os"
      "encoding/json"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create an SQL query
      sqlQuery := "SELECT * FROM person" +
          " WHERE location_country='mexico'" +
          " AND job_title_role='health'" +
          " AND phone_numbers IS NOT NULL;"

      // Create a parameters JSON object
      params := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 10,
              Pretty: true,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              SQL: sqlQuery,
          },
      }

      // Pass the parameters object to the Person Search API
      response, err := client.Person.Search(context.Background(), params)
      // Check for successful response
      if err == nil {
          data := response.Data
          // Create file
          out, outErr := os.Create("my_pdl_search.jsonl")
          defer out.Close()
          if (outErr == nil) {
              for i := range data {
                  // Convert each profile found to JSON
                  record, jsonErr := json.Marshal(data[i])
                  // Write out each profile to file
                  if (jsonErr == nil) {
                      out.WriteString(string(record) + "\n")
                  }
              }
              out.Sync()
          }
          fmt.Printf("Successfully grabbed %d records from PDL.\n", len(data))
          fmt.Printf("%d total PDL records exist matching this query.\n", response.Total)
      } else {
          fmt.Println("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
          fmt.Println("Error:", err)
      } 
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}},
              {"exists": {"field": "phone_numbers"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': json.dumps(ES_QUERY),
    'size': 10,
    'pretty': True
  }

  # Pass the parameters object to the Person Search API
  response = requests.get(
    PDL_URL,
    headers=HEADERS,
    params=PARAMS
  ).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```python Python3 (SQL) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE location_country='mexico'
    AND job_title_role='health'
    AND phone_numbers IS NOT NULL;
   """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 10,
    'pretty': True
  }

  # Pass the parameters object to the Person Search API
  response = requests.get(
    PDL_URL,
    headers=HEADERS,
    params=PARAMS
  ).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("error:", response)
  ```
</CodeGroup>

## Using POST Requests

*"I want to use POST requests instead of GET requests so that I can make queries with a lot of parameters."*

<Info>
  **Difference Between GET and POST Requests**

  See this article for a comparison of the [differences between GET and POST requests](https://www.w3schools.com/tags/ref_httpmethods.asp). The biggest difference is that POST requests don't have any limits on the amount of data that you can pass in the request.
</Info>

<CodeGroup>
  ```python Python3 (Elasticsearch) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}},
              {"exists": {"field": "phone_numbers"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': ES_QUERY, # This is a different syntax than when using GET requests
    'size': 10,
    'pretty': True
  }

  # Pass the parameters object to the Person Search API using POST method
  response = requests.post(
    PDL_URL,
    headers=HEADERS,
    json=PARAMS # Passing the data directly as a JSON object
    # data=json.dumps(PARAMS) # This is an alternative way of passing data using a string
  ).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```python Python3 (SQL) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE location_country='mexico'
    AND job_title_role='health'
    AND phone_numbers IS NOT NULL;
   """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 10,
    'pretty': True
  }

  # Pass the parameters object to the Person Search API using POST method
  response = requests.post(
    PDL_URL,
    headers=HEADERS,
    json=PARAMS # Pass the data directly as a JSON object
    # data=json.dumps(PARAMS) # This is an alternative way of passing data using a string
  ).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```bash cURL theme={null}
  # Elasticsearch
  curl -X POST \
    'https://api.peopledatalabs.com/v5/person/search' \
    -H 'X-Api-Key: your-api-key' \
    -H 'Content-Type: application/json' \
    -d '{
    "size": 10,
    "query": {
      "bool": {
        "must": [
          {"term": {"location_country": "mexico"}},
          {"term": {"job_title_role": "health"}},
          {"exists": {"field": "phone_numbers"}}
        ]
      }
    }
  }'

  # SQL
  curl -X POST \
    'https://api.peopledatalabs.com/v5/person/search' \
    -H 'X-Api-Key: your-api-key' \
    -H 'Content-Type: application/json' \
    -d '{
      "size": 10,
      "sql": "SELECT * FROM person WHERE location_country='\''mexico'\'' AND job_title_role='\''health'\'' AND phone_numbers IS NOT NULL;"
  }'
  ```
</CodeGroup>

## Searching Specific Datasets

*"I want to run a simple query against PDL's [Phone Dataset](/docs/datasets#phone-slice)."*

<Info>
  **Maintaining Backwards Compatibility**

  We introduced the `dataset` parameter with the [July 2021 release](/changelog/july-2021-release-notes#changing-the-default-de-duplication-in-the-search-api), in which we also changed the default dataset from `all` to `resume`. For users that want to maintain the same performance in their queries as prior to this change, set the `dataset` parameter to `all` in the example below.
</Info>

<CodeGroup>
  ```python Python3 SDK (Elasticsearch) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': ES_QUERY,
    'size': 10,
    'pretty': True,
    'dataset': "phone" # Search for records with a phone number
  }

  # Pass the parameters object to the Person Search API
  response = CLIENT.person.search(**PARAMS).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```python Python3 SDK (SQL) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE location_country='mexico'
    AND job_title_role='health'
    AND phone_numbers IS NOT NULL;
   """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 10,
    'pretty': True,
    'dataset': "phone" # Search for records with a phone number
  }

  # Pass the parameters object to the Person Search API
  response = CLIENT.person.search(**PARAMS).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```bash cURL theme={null}
  # Elasticsearch
  curl -X GET 'https://api.peopledatalabs.com/v5/person/search' \
  -H 'X-Api-Key: xxxx' \
  --data-raw '{
    "size": 10,
    "dataset": "all",
    "query": {
      "bool": {
        "must": [
          {"term": {"location_country": "mexico"}},
          {"term": {"job_title_role": "health"}},
        ]
      }
    }
  }'

  # SQL
  curl -X GET \
    'https://api.peopledatalabs.com/v5/person/search' \
    -H 'X-Api-Key: xxxx' \
    --data-raw '{
      "size": 10,
      "dataset: "phone",
      "sql": "SELECT * FROM person WHERE location_country='\''mexico'\'' AND job_title_role='\''health'\'' AND phone_numbers IS NOT NULL;"
  }'
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  import fs from 'fs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an Elasticsearch query
  const esQuery = {
    query: {
      bool: {
        must:[
          {term: {location_country: "mexico"}}, 
          {term: {job_title_role: "health"}}, 
        ]
      }
    }
  }

  // Create a parameters JSON object
  const params = {
    searchQuery: esQuery, 
    size: 10,
    pretty: true,
    dataset: "phone" // Search for records with a phone number
  }

  // Pass the parameters object to the Person Search API
  PDLJSClient.person.search.elastic(params).then((data) => {
      // Write out all profiles found to file
      fs.writeFile("my_pdl_search.jsonl", Buffer.from(JSON.stringify(data.data)), (err) => {
          if (err) throw err;
      });
      console.log(`Successfully grabbed ${data.data.length} records from PDL.`);
      console.log(`${data["total"]} total PDL records exist matching this query.`)
  }).catch((error) => {
      console.log("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
      console.log(error);
  });
  ```

  ```javascript JavaScript (SQL) theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  import fs from 'fs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an SQL query
  const sqlQuery = `SELECT * FROM person 
                    WHERE location_country='mexico' 
                    AND job_title_role='health';`

  // Create an Elasticsearch query
  const params = {
    searchQuery: sqlQuery, 
    size: 10,
    pretty: true,
    dataset: "phone" // Search for records with a phone number
  }

  // Pass the parameters object to the Person Search API
  PDLJSClient.person.search.sql(params).then((data) => {
      // Write out all profiles found to file
      fs.writeFile("my_pdl_search.jsonl", Buffer.from(JSON.stringify(data.data)), (err) => {
          if (err) throw err;
      });
      console.log(`Successfully grabbed ${data.data.length} records from PDL.`);
      console.log(`${data["total"]} total PDL records exist matching this query.`)
  }).catch((error) => {
      console.log("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
      console.log(error);
  });
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}}
        ]
      }
    }
  }

  # Pass parameters to the Person Search API
  response = Peopledatalabs::Search.people(searchType: 'elastic', query: ES_QUERY, size: 10, pretty: true, 'dataset': 'phone')

  # Check for successful response
  if response['status'] == 200
      data = response['data']
      # Write out each profile found to file
      File.open("my_pdl_search.jsonl", "w") do |out|
          data.each { |record| out.write(JSON.dump(record) + "\n") }
      end
      puts "Successfully grabbed #{data.length()} records from PDL."
      puts "#{response['total']} total PDL records exist matching this query."
  else
      puts "NOTE: The carrier pigeons lost motivation in flight. See error and try again."
      puts "Error: #{response}"
  end
  ```

  ```ruby Ruby (SQL) theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE location_country='mexico'
    AND job_title_role='health'
    AND phone_numbers IS NOT NULL;
   """

  # Pass parameters to the Person Search API
  response = Peopledatalabs::Search.people(searchType: 'sql', query: SQL_QUERY, size: 10, pretty: true, 'dataset': 'phone')

  # Check for successful response
  if response['status'] == 200
      data = response['data']
      # Write out each profile found to file
      File.open("my_pdl_search.jsonl", "w") do |out|
          data.each { |record| out.write(JSON.dump(record) + "\n") }
      end
      puts "Successfully grabbed #{data.length()} records from PDL."
      puts "#{response['total']} total PDL records exist matching this query."
  else
      puts "NOTE: The carrier pigeons lost motivation in flight. See error and try again."
      puts "Error: #{response}"
  end
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "os"
      "encoding/json"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create an Elasticsearch query
      elasticSearchQuery := map[string]interface{} {
          "query": map[string]interface{} {
              "bool": map[string]interface{} {
                  "must": []map[string]interface{} {
                      {"term": map[string]interface{}{"location_country": "mexico"}},
                      {"term": map[string]interface{}{"job_title_role": "health"}},
                   },
              },
          },
      }

      // Create a parameters JSON object
      params := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 10,
              Pretty: true,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              Query: elasticSearchQuery,
              Dataset: "phone", // Search for records with a phone number
          },
      }

      // Pass the parameters object to the Person Search API
      response, err := client.Person.Search(context.Background(), params)
      // Check for successful response
      if err == nil {
          data := response.Data
          // Create file
          out, outErr := os.Create("my_pdl_search.jsonl")
          defer out.Close()
          if (outErr == nil) {
              for i := range data {
                  // Convert each profile found to JSON
                  record, jsonErr := json.Marshal(data[i])
                  // Write out each profile to file
                  if (jsonErr == nil) {
                      out.WriteString(string(record) + "\n")
                  }
              }
              out.Sync()
          }
          fmt.Printf("Successfully grabbed %d records from PDL.\n", len(data))
          fmt.Printf("%d total PDL records exist matching this query.\n", response.Total)
      } else {
          fmt.Println("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
          fmt.Println("Error:", err)
      } 
  }
  ```

  ```go Go (SQL) expandable theme={null}
  package main

  import (
      "fmt"
      "os"
      "encoding/json"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create an SQL query
      sqlQuery := "SELECT * FROM person" +
          " WHERE location_country='mexico'" +
          " AND job_title_role='health';"
   
      // Create a parameters JSON object
      params := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 10,
              Pretty: true,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              SQL: sqlQuery,
              Dataset: "phone", // Search for records with a phone number
          },
      }

      // Pass the parameters object to the Person Search API
      response, err := client.Person.Search(context.Background(), params)
      // Check for successful response
      if err == nil {
          data := response.Data
          // Create file
          out, outErr := os.Create("my_pdl_search.jsonl")
          defer out.Close()
          if (outErr == nil) {
              for i := range data {
                  // Convert each profile found to JSON
                  record, jsonErr := json.Marshal(data[i])
                  // Write out each profile to file
                  if (jsonErr == nil) {
                      out.WriteString(string(record) + "\n")
                  }
              }
              out.Sync()
          }
          fmt.Printf("Successfully grabbed %d records from PDL.\n", len(data))
          fmt.Printf("%d total PDL records exist matching this query.\n", response.Total)
      } else {
          fmt.Println("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
          fmt.Println("Error:", err)
      } 
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': json.dumps(ES_QUERY),
    'size': 10,
    'pretty': True,
    'dataset': "phone" # Search for records with a phone number
  }

  # Pass the parameters object to the Person Search API
  response = requests.get(
    PDL_URL,
    headers=HEADERS,
    params=PARAMS
  ).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```python Python3 (SQL) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE location_country='mexico'
    AND job_title_role='health'
    AND phone_numbers IS NOT NULL;
   """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 10,
    'pretty': True,
    'dataset': "phone" # Search for records with a phone number
  }

  # Pass the parameters object to the Person Search API
  response = requests.get(
    PDL_URL,
    headers=HEADERS,
    params=PARAMS
  ).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("error:", response)
  ```
</CodeGroup>

## Excluding Datasets

*"I want to run a simple query against all PDL datasets except the [email](/docs/email-stats) and [phone](/docs/datasets#phone-slice) datasets."*

<CodeGroup>
  ```python Python3 SDK (Elasticsearch) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': ES_QUERY,
    'size': 10,
    'pretty': True,
    'dataset': "-email,phone" # Search all datasets EXCEPT the email and phone slices
  }

  # Pass the parameters object to the Person Search API
  response = CLIENT.person.search(**PARAMS).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  import fs from 'fs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an Elasticsearch query
  const esQuery = {
    query: {
      bool: {
        must:[
          {term: {location_country: "mexico"}}, 
          {term: {job_title_role: "health"}}, 
        ]
      }
    }
  }

  // Create a parameters JSON object
  const params = {
    searchQuery: esQuery, 
    size: 10,
    pretty: true,
    dataset: "-email,phone" // Search all datasets EXCEPT the email and phone slices
  }

  // Pass the parameters object to the Person Search API
  PDLJSClient.person.search.elastic(params).then((data) => {
      // Write out all profiles found to file
      fs.writeFile("my_pdl_search.jsonl", Buffer.from(JSON.stringify(data.data)), (err) => {
          if (err) throw err;
      });
      console.log(`Successfully grabbed ${data.data.length} records from PDL.`);
      console.log(`${data["total"]} total PDL records exist matching this query.`)
  }).catch((error) => {
      console.log("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
      console.log(error);
  });
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}}
        ]
      }
    }
  }

  # Pass parameters to the Person Search API
  response = Peopledatalabs::Search.people(searchType: 'elastic', query: ES_QUERY, size: 10, pretty: true, 'dataset': '-email,phone')

  # Check for successful response
  if response['status'] == 200
      data = response['data']
      # Write out each profile found to file
      File.open("my_pdl_search.jsonl", "w") do |out|
          data.each { |record| out.write(JSON.dump(record) + "\n") }
      end
      puts "Successfully grabbed #{data.length()} records from PDL."
      puts "#{response['total']} total PDL records exist matching this query."
  else
      puts "NOTE: The carrier pigeons lost motivation in flight. See error and try again."
      puts "Error: #{response}"
  end
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "os"
      "encoding/json"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create an Elasticsearch query
      elasticSearchQuery := map[string]interface{} {
          "query": map[string]interface{} {
              "bool": map[string]interface{} {
                  "must": []map[string]interface{} {
                      {"term": map[string]interface{}{"location_country": "mexico"}},
                      {"term": map[string]interface{}{"job_title_role": "health"}},
                   },
              },
          },
      }

      // Create a parameters JSON object
      params := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 10,
              Pretty: true,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              Query: elasticSearchQuery,
              Dataset: "-email,phone", // Search all datasets EXCEPT the email and phone slices
          },
      }

      // Pass the parameters object to the Person Search API
      response, err := client.Person.Search(context.Background(), params)
      // Check for successful response
      if err == nil {
          data := response.Data
          // Create file
          out, outErr := os.Create("my_pdl_search.jsonl")
          defer out.Close()
          if (outErr == nil) {
              for i := range data {
                  // Convert each profile found to JSON
                  record, jsonErr := json.Marshal(data[i])
                  // Write out each profile to file
                  if (jsonErr == nil) {
                      out.WriteString(string(record) + "\n")
                  }
              }
              out.Sync()
          }
          fmt.Printf("Successfully grabbed %d records from PDL.\n", len(data))
          fmt.Printf("%d total PDL records exist matching this query.\n", response.Total)
      } else {
          fmt.Println("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
          fmt.Println("Error:", err)
      } 
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"location_country": "mexico"}},
              {"term": {"job_title_role": "health"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': json.dumps(ES_QUERY),
    'size': 10,
    'pretty': True,
    'dataset': "-email,phone" # Search all datasets EXCEPT the email and phone slices
  }

  # Pass the parameters object to the Person Search API
  response = requests.get(
    PDL_URL,
    headers=HEADERS,
    params=PARAMS
  ).json()

  # Check for successful response
  if response["status"] == 200:
    data = response['data']
    # Write out each profile found to file
    with open("my_pdl_search.jsonl", "w") as out:
      for record in data:
        out.write(json.dumps(record) + "\n")
    print(f"Successfully grabbed {len(data)} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The carrier pigeons lost motivation in flight. See error and try again.")
    print("Error:", response)
  ```
</CodeGroup>

## Bulk Retrieval

*"I want to pull all current employees at Amazon and save their profiles to a CSV file."*

<Warning>
  **High Credit Usage Code Below**

  The code example below illustrates retrieving all the employee profiles in a large company and is meant primarily for demonstrating the use of the `scroll_token` parameter when requesting large amounts of records. As a result, this code is mostly illustrative in purpose. It can further expend a lot of credits and doesn't have any error handling. The `MAX_NUM_RECORDS_LIMIT` parameter in the example sets the maximum number of profiles that we will retrieve (and the maximum number of credits that you will expend), so please set it accordingly when testing this example.
</Warning>

<CodeGroup>
  ```python Python3 SDK (Elasticsearch) expandable theme={null}
  import json, time, csv

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Limit the number of records to pull (to prevent accidentally using 
  # more credits than expected when testing this code)
  MAX_NUM_RECORDS_LIMIT = 150 # The maximum number of records to retrieve
  USE_MAX_NUM_RECORDS_LIMIT = True # Set to False to pull all available records

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"job_company_name": "amazon"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': ES_QUERY,
    'size': 100, 
    'pretty': True
  }

  # Pull all results in multiple batches
  batch = 1
  # Store all records retreived in an array
  all_records = []
  # Time the process
  start_time = time.time()
  found_all_records = False
  continue_scrolling = True

  # While still scrolling through data and still records to be found
  while continue_scrolling and not found_all_records: 

    # Check if we reached the maximum number of records we want
    if USE_MAX_NUM_RECORDS_LIMIT:
      num_records_to_request = MAX_NUM_RECORDS_LIMIT - len(all_records)
      # Adjust size parameter
      PARAMS['size'] = max(0, min(100, num_records_to_request))
      # Check if MAX_NUM_RECORDS_LIMIT reached
      if num_records_to_request == 0:
        print(f"Stopping - reached maximum number of records to pull "
              f"[MAX_NUM_RECORDS_LIMIT = {MAX_NUM_RECORDS_LIMIT}].")
        break

    # Pass the parameters object to the Person Search API
    response = CLIENT.person.search(**PARAMS).json()

    # Check for successful response
    if response['status'] == 200:
      # Add records retrieved to the records array
      all_records.extend(response['data'])
      print(f"Retrieved {len(response['data'])} records in batch {batch} "
            f"- {response['total'] - len(all_records)} records remaining.")
    else:
      print(f"Error retrieving some records:\n\t"
            f"[{response['status']} - {response['error']['type']}] "
            f"{response['error']['message']}")
    
    # Get scroll_token from response if exists and store it in parameters object
    if 'scroll_token' in response:
      PARAMS['scroll_token'] = response['scroll_token']
    else:
      continue_scrolling = False
      print(f"Unable to continue scrolling.")

    batch += 1
    found_all_records = (len(all_records) == response['total'])
    time.sleep(6) # Avoid hitting rate limit thresholds
   
  # Calculate time required to process batches
  end_time = time.time()
  runtime = end_time - start_time
          
  print(f"Successfully recovered {len(all_records)} profiles in "
        f"{batch} batches [{round(runtime, 2)} seconds].")

  # Save profiles to CSV (utility function)
  def save_profiles_to_csv(profiles, filename, fields=[], delim=','):
    # Define header fields
    if fields == [] and len(profiles) > 0:
        fields = profiles[0].keys()
    # Write CSV file
    with open(filename, 'w') as csvfile:
      writer = csv.writer(csvfile, delimiter=delim)
      # Write header
      writer.writerow(fields)
      # Write body
      count = 0
      for profile in profiles:
        writer.writerow([ profile[field] for field in fields ])
        count += 1
    print(f"Wrote {count} lines to: '{filename}'.")

  # Use utility function to save all records retrieved to CSV    
  csv_header_fields = ['work_email', 'full_name', "linkedin_url",
                       'job_title', 'job_company_name']
  csv_filename = "all_employee_profiles.csv"
  save_profiles_to_csv(all_records, csv_filename, csv_header_fields)
  ```

  ```python Python3 SDK (SQL) expandable theme={null}
  import json, time, csv

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Limit the number of records to pull (to prevent accidentally using 
  # more credits than expected when testing this code)
  MAX_NUM_RECORDS_LIMIT = 150 # The maximum number of records to retrieve
  USE_MAX_NUM_RECORDS_LIMIT = True # Set to False to pull all available records

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an SQL query
  SQL_QUERY = \
  """
   SELECT * FROM person
   WHERE job_company_name='amazon';
  """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 100, 
    'pretty': True
  }

  # Pull all results in multiple batches
  batch = 1
  # Store all records retreived in an array
  all_records = []
  # Time the process
  start_time = time.time()
  found_all_records = False
  continue_scrolling = True

  # While still scrolling through data and still records to be found
  while continue_scrolling and not found_all_records: 

    # Check if we reached the maximum number of records we want
    if USE_MAX_NUM_RECORDS_LIMIT:
      num_records_to_request = MAX_NUM_RECORDS_LIMIT - len(all_records)
      # Adjust size parameter
      PARAMS['size'] = max(0, min(100, num_records_to_request))
      # Check if MAX_NUM_RECORDS_LIMIT reached
      if num_records_to_request == 0:
        print(f"Stopping - reached maximum number of records to pull "
              f"[MAX_NUM_RECORDS_LIMIT = {MAX_NUM_RECORDS_LIMIT}].")
        break

    # Pass the parameters object to the Person Search API
    response = CLIENT.person.search(**PARAMS).json()

    # Check for successful response
    if response['status'] == 200:
      # Add records retrieved to the records array
      all_records.extend(response['data'])
      print(f"Retrieved {len(response['data'])} records in batch {batch} "
            f"- {response['total'] - len(all_records)} records remaining.")
    else:
      print(f"Error retrieving some records:\n\t"
            f"[{response['status']} - {response['error']['type']}] "
            f"{response['error']['message']}")
    
    # Get scroll_token from response if exists and store it in parameters object
    if 'scroll_token' in response:
      PARAMS['scroll_token'] = response['scroll_token']
    else:
      continue_scrolling = False
      print(f"Unable to continue scrolling.")

    batch += 1
    found_all_records = (len(all_records) == response['total'])
    time.sleep(6) # Avoid hitting rate limit thresholds
   
  # Calculate time required to process batches
  end_time = time.time()
  runtime = end_time - start_time
          
  print(f"Successfully recovered {len(all_records)} profiles in "
        f"{batch} batches [{round(runtime, 2)} seconds].")

  # Save profiles to CSV (utility function)
  def save_profiles_to_csv(profiles, filename, fields=[], delim=','):
    # Define header fields
    if fields == [] and len(profiles) > 0:
        fields = profiles[0].keys()
    # Write CSV file
    with open(filename, 'w') as csvfile:
      writer = csv.writer(csvfile, delimiter=delim)
      # Write header
      writer.writerow(fields)
      # Write body
      count = 0
      for profile in profiles:
        writer.writerow([ profile[field] for field in fields ])
        count += 1
    print(f"Wrote {count} lines to: '{filename}'.")

  # Use utility function to save all records retrieved to CSV  
  csv_header_fields = ['work_email', 'full_name', "linkedin_url",
                       'job_title', 'job_company_name']
  csv_filename = "all_employee_profiles.csv"
  save_profiles_to_csv(all_records, csv_filename, csv_header_fields)
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // See https://www.npmjs.com/package/csv-writer
  import * as csvwriter from 'csv-writer';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Limit the number of records to pull (to prevent accidentally using 
  // more credits than expected when testing this code)
  const maxNumRecordsLimit = 150;     // The maximum number of records to retrieve
  const useMaxNumRecordsLimit = true; // Set to false to pull all available records

  // Create an Elasticsearch query
  const esQuery = {
    query: {
      bool: {
        must:[
          {term: {job_company_name: "amazon"}}, 
        ]
      }
    }
  }

  // Create a parameters JSON object
  var params = {
    searchQuery: esQuery, 
    size: 100,
    scroll_token: null,
    pretty: true
  }

  // Pull all results in multiple batches
  var batch = 1;
  // Store all records retreived in an array
  var allRecords = [];
  // Time the process
  var startTime = Date.now();
  var foundAllRecords = false;
  var continueScrolling = true;
  var numRetrieved = 0;
  // Queue parameter objects in order to iterate through batches
  var paramQueue = [];
  // The current scroll_token
  var scrollToken = null;
  var numRecordsToRequest = 100;

  while (numRecordsToRequest > 0) { 

      // Check if we reached the maximum number of records we want
      if (useMaxNumRecordsLimit) {
          numRecordsToRequest = maxNumRecordsLimit - numRetrieved;
          // Adjust size parameter
          params.size = Math.max(0, Math.min(100, numRecordsToRequest));
          numRetrieved += params.size;
          // Add batch to the parameter queue
          if (params.size > 0) {       
              paramQueue.push(JSON.parse(JSON.stringify(params)));
          }
      } else {
          break;
      }
  }

  // Run initial batch
  runBatch();

  // Retrieve records associated with a batch
  function runBatch() {
      // Get the parameters for the current batch
      let currParams = useMaxNumRecordsLimit ? paramQueue[batch-1] : params;
      // Set the scroll_token from the previous batch
      currParams.scroll_token = scrollToken;
      batch++;
                  
      // Pass the current parameters object to the Person Search API
      PDLJSClient.person.search.elastic(currParams).then((data) => {
          // Add records retrieved to the records array
          Array.prototype.push.apply(allRecords, data.data);
              
          // Store the scroll_token if exists
          if (data['scroll_token']) {
              scrollToken = data['scroll_token'];
          } else {
              continueScrolling = false;
              console.log("Unable to continue scrolling.");
          }
              
          foundAllRecords = (allRecords.length == data['total']);
              
          console.log(`Retrieved ${data.data.length} records in batch ${(batch-1)}` +
              ` - ${(data['total'] - allRecords.length)} records remaining.`);
              
          // Run next batch recursively, if any
          if (!foundAllRecords && (batch <= paramQueue.length || !useMaxNumRecordsLimit)) {
              runBatch();
          } else {
              console.log(`Stopping - reached maximum number of records to pull [maxNumRecordsLimit = ` +
                  `${maxNumRecordsLimit}].`);  
                  
              // Calculate time required to process batches
              let endTime = Date.now();
              let runTime = endTime - startTime;
              console.log (`Successfully recovered ${allRecords.length} profiles in ` +
                  `${(batch-1)} batches [${Math.round(runTime/1000)} seconds].`);
                  
              // Set CSV fields
              let csvHeaderFields = [
                  {id: "work_email", title: "work_email"},
                  {id: "full_name", title: "full_name"}, 
                  {id: "linkedin_url", title: "linkedin_url"},
                  {id: "job_title", title: "job_title"},
                  {id: "job_company_name", title: "job_company_name"}
              ];
              let csvFilename = "all_employee_profiles.csv";
              // Write records array to CSV file
              saveProfilesToCSV(allRecords, csvFilename, csvHeaderFields);           
          }
      }).catch((error) => {
          console.log(error);
      });

  }

  // Write CSV file using csv-writer (https://www.npmjs.com/package/csv-writer) 
  // $ npm i -s csv-writer
  function saveProfilesToCSV(profiles, filename, fields) {

      // Create CSV file
      const createCsvWriter = csvwriter.createObjectCsvWriter;
      const csvWriter = createCsvWriter({
          path: filename,
          header: fields
      });
        
      let data = [];
      // Iterate through records array
      for (let i = 0; i < profiles.length; i++) {
          let record = profiles[i];
          data[i] = {};
          // Store requested fields
          for (let field in fields) {
              data[i][fields[field].id] = record[fields[field].id];    
          }
       }

      // Write data to CSV file
      csvWriter
          .writeRecords(data)
          .then(()=> console.log('The CSV file was written successfully.'));
  }
  ```

  ```javascript JavaScript (SQL) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // See https://www.npmjs.com/package/csv-writer
  import * as csvwriter from 'csv-writer';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Limit the number of records to pull (to prevent accidentally using 
  // more credits than expected when testing out this code).
  const maxNumRecordsLimit = 150;     // The maximum number of records to retrieve
  const useMaxNumRecordsLimit = true; // Set to false to pull all available records

  // Create an SQL query
  const sqlQuery = `SELECT * FROM person
      WHERE job_company_name='amazon';`;

  // Create a parameters JSON object
  var params = {
    searchQuery: sqlQuery, 
    size: 100,
    scroll_token: null,
    pretty: true
  }

  // Pull all results in multiple batches
  var batch = 1;
  // Store all records retreived in an array
  var allRecords = [];
  // Time the process
  var startTime = Date.now();
  var foundAllRecords = false;
  var continueScrolling = true;
  var numRetrieved = 0;
  // Queue parameter objects in order to iterate through batches
  var paramQueue = [];
  // The current scroll_token
  var scrollToken = null;
  var numRecordsToRequest = 100;

  while (numRecordsToRequest > 0) { 

      // Check if we reached the maximum number of records we want
      if (useMaxNumRecordsLimit) {
          numRecordsToRequest = maxNumRecordsLimit - numRetrieved;
          // Adjust size parameter
          params.size = Math.max(0, Math.min(100, numRecordsToRequest));
          numRetrieved += params.size;
          // Add batch to the parameter queue
          if (params.size > 0) {       
              paramQueue.push(JSON.parse(JSON.stringify(params)));
          }
      } else {
          break;
      }
  }

  // Run initial batch
  runBatch();

  // Retrieve records associated with a batch
  function runBatch() {
      // Get the parameters for the current batch
      let currParams = useMaxNumRecordsLimit ? paramQueue[batch-1] : params;
      // Set the scroll_token from the previous batch
      currParams.scroll_token = scrollToken;
      batch++;
                  
      // Pass the current parameters object to the Person Search API
      PDLJSClient.person.search.sql(currParams).then((data) => {
          // Add records retrieved to the records array
          Array.prototype.push.apply(allRecords, data.data);
              
          // Store the scroll_token if exists
          if (data['scroll_token']) {
              scrollToken = data['scroll_token'];
          } else {
              continueScrolling = false;
              console.log("Unable to continue scrolling.");
          }
              
          foundAllRecords = (allRecords.length == data['total']);
              
          console.log(`Retrieved ${data.data.length} records in batch ${(batch-1)}` +
              ` - ${(data['total'] - allRecords.length)} records remaining.`);
              
          // Run next batch recursively, if any
          if (!foundAllRecords && (batch <= paramQueue.length || !useMaxNumRecordsLimit)) {
              runBatch();
          } else {
              console.log(`Stopping - reached maximum number of records to pull [maxNumRecordsLimit = ` +
                  `${maxNumRecordsLimit}].`);  
                  
              // Calculate time required to process batches
              let endTime = Date.now();
              let runTime = endTime - startTime;
              console.log (`Successfully recovered ${allRecords.length} profiles in ` +
                  `${(batch-1)} batches [${Math.round(runTime/1000)} seconds].`);
                  
              // Set CSV fields
              let csvHeaderFields = [
                  {id: "work_email", title: "work_email"},
                  {id: "full_name", title: "full_name"}, 
                  {id: "linkedin_url", title: "linkedin_url"},
                  {id: "job_title", title: "job_title"},
                  {id: "job_company_name", title: "job_company_name"}
              ];
              let csvFilename = "all_employee_profiles.csv";
              // Write records array to CSV file
              saveProfilesToCSV(allRecords, csvFilename, csvHeaderFields);           
          }
      }).catch((error) => {
          console.log(error);
      });

  }

  // Write CSV file using csv-writer (https://www.npmjs.com/package/csv-writer)
  // $ npm i -s csv-writer
  function saveProfilesToCSV(profiles, filename, fields) {

      // Create CSV file
      const createCsvWriter = csvwriter.createObjectCsvWriter;
      const csvWriter = createCsvWriter({
          path: filename,
          header: fields
      });
      
      let data = [];
      for (let i = 0; i < profiles.length; i++) {
          let record = profiles[i];
          data[i] = {};
          // Store requested fields
          for (let field in fields) {
              data[i][fields[field].id] = record[fields[field].id];    
          }
       }

      // Write data to CSV file
      csvWriter
          .writeRecords(data)
          .then(()=> console.log('The CSV file was written successfully.'));
  }
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  require 'json'
  require 'csv'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Limit the number of records to pull (to prevent accidentally using 
  # more credits than expected when testing out this code).
  MAX_NUM_RECORDS_LIMIT = 150 # The maximum number of records to retrieve
  USE_MAX_NUM_RECORDS_LIMIT = true # Set to false to pull all available records

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"job_company_name": "amazon"}}
        ]
      }
    }
  }

  # Pull all results in multiple batches
  batch = 1
  # Store all records retreived in an array
  all_records = []
  # Time the process
  start_time = Time.now
  found_all_records = false
  continue_scrolling = true
  scroll_token = {}

  # While still scrolling through data and still records to be found
  while continue_scrolling && !found_all_records do 

    # Check if we reached the maximum number of records we want
    if USE_MAX_NUM_RECORDS_LIMIT
      num_records_to_request = MAX_NUM_RECORDS_LIMIT - all_records.length()
      # Adjust size parameter
      size = [0, [100, num_records_to_request].min].max
      # Check if MAX_NUM_RECORDS_LIMIT reached
      if num_records_to_request == 0
        puts "Stopping - reached maximum number of records to pull "
        puts "[MAX_NUM_RECORDS_LIMIT = #{MAX_NUM_RECORDS_LIMIT}]."
        break
      end
    end

    # Pass parameters to the Person Search API
    response = Peopledatalabs::Search.person(searchType: 'elastic', query: ES_QUERY, size: size, scroll_token: scroll_token, pretty: true)

    # Check for successful response
    if response['status'] == 200
      # Add records retrieved to the records array
      all_records += response['data']
      puts "Retrieved #{response['data'].length()} records in batch #{batch} "
      puts  "- #{response['total'] - all_records.length()} records remaining."
    else
      puts "Error retrieving some records:\n\t"
      puts "[#{response['status']} - #{response['error']['type']}] "
      puts response['error']['message']
    end
    
    # Get scroll_token from response if exists and store it
    if response.key?('scroll_token')
      scroll_token = response['scroll_token']
    else
      continue_scrolling = false
      puts "Unable to continue scrolling."
    end

    batch += 1
    found_all_records = (all_records.length() == response['total'])
    sleep(6) # Avoid hitting rate limit thresholds
  end

  # Calculate time required to process batches
  end_time = Time.now
  runtime = end_time - start_time
          
  puts "Successfully recovered #{all_records.length()} profiles in "
  puts "#{batch} batches [#{runtime.round(2)} seconds]."

  # Save profiles to CSV (utility function)
  def save_profiles_to_csv(profiles, filename, fields=[], delim=',')
    # Define header fields
    if fields == [] && profiles.length() > 0
        fields = profiles[0].keys
    end
      
    count = 0
    # Write CSV file
    CSV.open(filename, 'w') do |writer|
      # Write header
      writer << fields
      # Write body
      profiles.each do |profile|
        record = []
        fields.each do |field| 
          record << profile[field]
          count += 1
        end
        writer << record
      end
    end
    puts "Wrote #{count} lines to: '#{filename}'."
  end

  # Use utility function to save profiles to CSV    
  csv_header_fields = ['work_email', 'full_name', "linkedin_url",
                       'job_title', 'job_company_name']
  csv_filename = "all_company_profiles.csv"
  save_profiles_to_csv(all_records, csv_filename, csv_header_fields)
  ```

  ```ruby Ruby (SQL) expandable theme={null}
  require 'json'
  require 'csv'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Limit the number of records to pull (to prevent accidentally using 
  # more credits than expected when testing out this code).
  MAX_NUM_RECORDS_LIMIT = 150 # The maximum number of records to retrieve
  USE_MAX_NUM_RECORDS_LIMIT = true # Set to false to pull all available records

  # Create an SQL query
  SQL_QUERY = \
  """
   SELECT * FROM person
   WHERE job_company_name='amazon';
  """

  # Pull all results in multiple batches
  batch = 1
  # Store all records retreived in an array
  all_records = []
  # Time the process
  start_time = Time.now
  found_all_records = false
  continue_scrolling = true
  scroll_token = {}

  # While still scrolling through data and still records to be found
  while continue_scrolling && !found_all_records do 

    # Check if we reached the maximum number of records we want
    if USE_MAX_NUM_RECORDS_LIMIT
      num_records_to_request = MAX_NUM_RECORDS_LIMIT - all_records.length()
      # Adjust size parameter
      size = [0, [100, num_records_to_request].min].max
      # Check if MAX_NUM_RECORDS_LIMIT reached
      if num_records_to_request == 0
        puts "Stopping - reached maximum number of records to pull "
        puts "[MAX_NUM_RECORDS_LIMIT = #{MAX_NUM_RECORDS_LIMIT}]."
        break
      end
    end

    # Pass parameters to the Person Search API
    response = Peopledatalabs::Search.person(searchType: 'sql', query: SQL_QUERY, size: size, scroll_token: scroll_token, pretty: true)

    # Check for successful response
    if response['status'] == 200
      # Add records retrieved to the records array
      all_records += response['data']
      puts "Retrieved #{response['data'].length()} records in batch #{batch} "
      puts  "- #{response['total'] - all_records.length()} records remaining."
    else
      puts "Error retrieving some records:\n\t"
      puts "[#{response['status']} - #{response['error']['type']}] "
      puts response['error']['message']
    end
    
    # Get scroll_token from response if exists and store it
    if response.key?('scroll_token')
      scroll_token = response['scroll_token']
    else
      continue_scrolling = false
      puts "Unable to continue scrolling."
    end

    batch += 1
    found_all_records = (all_records.length() == response['total'])
    sleep(6) # Avoid hitting rate limit thresholds
  end

  # Calculate time required to process batches
  end_time = Time.now
  runtime = end_time - start_time
          
  puts "Successfully recovered #{all_records.length()} profiles in "
  puts "#{batch} batches [#{runtime.round(2)} seconds]."

  # Save profiles to CSV (utility function)
  def save_profiles_to_csv(profiles, filename, fields=[], delim=',')
    # Define header fields
    if fields == [] && profiles.length() > 0
        fields = profiles[0].keys
    end
      
    count = 0
    # Write CSV file
    CSV.open(filename, 'w') do |writer|
      # Write header
      writer << fields
      # Write body
      profiles.each do |profile|
        record = []
        fields.each do |field| 
          record << profile[field]
          count += 1
        end
        writer << record
      end
    end
    puts "Wrote #{count} lines to: '#{filename}'."
  end

  # Use utility function to save profiles to CSV    
  csv_header_fields = ['work_email', 'full_name', "linkedin_url",
                       'job_title', 'job_company_name']
  csv_filename = "all_company_profiles.csv"
  save_profiles_to_csv(all_records, csv_filename, csv_header_fields)
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "time"
      "os"
      "math"
      "reflect"
      "encoding/json"
      "encoding/csv"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Limit the number of records to pull (to prevent accidentally using 
      // more credits than expected when testing out this code).
      const maxNumRecordsLimit = 150 // The maximum number of records to retrieve
      const useMaxNumRecordsLimit = true // Set to False to pull all available records

      // Create an Elasticsearch query
      elasticSearchQuery := map[string]interface{} {
          "query": map[string]interface{} {
              "bool": map[string]interface{} {
                  "must": []map[string]interface{} {
                      {"term": map[string]interface{}{"job_company_name": "amazon"}},
                  },
              },
          },
      }

      // Create a parameters JSON object
      p := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 100,
              Pretty: true,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              Query: elasticSearchQuery,
          },
      }

      // Pull all results in multiple batches
      batch := 1
      // Store all records retreived in an array
      var allRecords []pdlmodel.Person
      // Time the process
      startTime := time.Now()
      foundAllRecords := false
      continueScrolling := true
      var numRecordsToRequest int
      
      // While still scrolling through data and still records to be found
      for continueScrolling && !foundAllRecords {
          // Check if we reached the maximum number of records we want
          if useMaxNumRecordsLimit {
              numRecordsToRequest = maxNumRecordsLimit - len(allRecords)
              // Adjust size parameter
              p.BaseParams.Size = (int) (math.Max(0.0, math.Min(100.0, (float64) (numRecordsToRequest))))
              // Check if MAX_NUM_RECORDS_LIMIT reached
              if numRecordsToRequest == 0 {
                  fmt.Printf("Stopping - reached maximum number of records to pull " +
                             "[MAX_NUM_RECORDS_LIMIT = %d].\n", maxNumRecordsLimit)
                  
                  break
              }
          }
          
          // Pass the parameters object to the Person Search API
          response, err := client.Person.Search(context.Background(), p)
          
          // Check for successful response
          if err == nil {
              fmt.Printf("Retrieved %d records in batch %d - %d records remaining.\n", 
                         len(response.Data), batch, response.Total - len(allRecords))
          } else {
              fmt.Println("Error retrieving some records:\n\t",
                         err)
          }
          
          // Convert response to JSON
          var data map[string]interface{}
          jsonResponse, jsonErr := json.Marshal(response)
          if jsonErr == nil {
              json.Unmarshal(jsonResponse, &data)
              // Get scroll_token from response if exists and store it in parameters object
              if scrollToken, ok := data["scroll_token"]; ok {
                  p.SearchBaseParams.ScrollToken = fmt.Sprintf("%v", scrollToken)
              } else {
                  continueScrolling = false
                  fmt.Println("Unable to continue scrolling.")
              }
              // Add records retrieved to the records array
              allRecords = append(allRecords, response.Data...)
          }        
          batch++
          foundAllRecords = (len(allRecords) == response.Total)
          time.Sleep(6 * time.Second) // avoid hitting rate limit thresholds
      }
      
      // Calculate time required to process batches
      endTime := time.Now()
      runtime := endTime.Sub(startTime).Seconds()
          
      fmt.Printf("Successfully recovered %d profiles in %d batches [%d seconds].\n",
                 len(allRecords), batch, (int) (math.Round((float64) (runtime))))
      
      // Use utility function to save profiles to CSV    
      csvHeaderFields := []string{"work_email", "full_name", "linkedin_url",
                                  "job_title", "job_company_name"}
      csvFilename := "all_employee_profiles.csv"
      saveProfilesToCsv(allRecords, csvFilename, csvHeaderFields, ",")
  }

  // Save profiles to CSV (utility function)
  func saveProfilesToCsv(profiles []pdlmodel.Person, filename string, fields []string, delim string) {
      // Define header fields
      if fields == nil && len(profiles) > 0 {
          e := reflect.ValueOf(&(profiles[0])).Elem()
          for i := 0; i < e.NumField(); i++ {
              fields = append(fields, e.Type().Field(i).Name)
          }
      }
      
      // Write CSV file
      csvFile, err := os.Create(filename)
      if err == nil {
          csvwriter := csv.NewWriter(csvFile)
          defer csvwriter.Flush()
          // Write header
          csvwriter.Write(fields)
          // Write body
          count := 0
          for i := range profiles {
              var data map[string]interface{}
              jsonResponse, jsonErr := json.Marshal(profiles[i])
              if jsonErr == nil {
                  json.Unmarshal(jsonResponse, &data)
                  var record []string
                  for j := range fields {
                      record = append(record, fmt.Sprintf("%v", data[fields[j]]))
                  }
                  csvwriter.Write(record)
                  count++
              }
          }
          fmt.Printf("Wrote %d lines to: %s.\n", count, filename)
      }
  }
  ```

  ```go Go (SQL) expandable theme={null}
  package main

  import (
      "fmt"
      "time"
      "os"
      "math"
      "reflect"
      "encoding/json"
      "encoding/csv"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Limit the number of records to pull (to prevent accidentally using 
      // more credits than expected when testing out this code).
      const maxNumRecordsLimit = 150 // The maximum number of records to retrieve
      const useMaxNumRecordsLimit = true // Set to False to pull all available records

      // Create an SQL query
      sqlQuery := "SELECT * FROM person" +
          " WHERE job_company_name='amazon'"

      // Create a parameters JSON object
      p := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 100,
              Pretty: true,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              SQL: sqlQuery,
          },
      }

      // Pull all results in multiple batches
      batch := 1
      // Store all records retreived in an array
      var allRecords []pdlmodel.Person
      // Time the process
      startTime := time.Now()
      foundAllRecords := false
      continueScrolling := true
      var numRecordsToRequest int
      
      // While still scrolling through data and still records to be found
      for continueScrolling && !foundAllRecords {
          // Check if we reached the maximum number of records we want
          if useMaxNumRecordsLimit {
              numRecordsToRequest = maxNumRecordsLimit - len(allRecords)
              // Adjust size parameter
              p.BaseParams.Size = (int) (math.Max(0.0, math.Min(100.0, (float64) (numRecordsToRequest))))
              // Check if MAX_NUM_RECORDS_LIMIT reached
              if numRecordsToRequest == 0 {
                  fmt.Printf("Stopping - reached maximum number of records to pull " +
                             "[MAX_NUM_RECORDS_LIMIT = %d].\n", maxNumRecordsLimit)
                  
                  break
              }
          }
          
          // Pass the parameters object to the Person Search API
          response, err := client.Person.Search(context.Background(), p)
          
          // Check for successful response
          if err == nil {
              fmt.Printf("Retrieved %d records in batch %d - %d records remaining.\n", 
                         len(response.Data), batch, response.Total - len(allRecords))
          } else {
              fmt.Println("Error retrieving some records:\n\t",
                         err)
          }
          
          // Convert response to JSON
          var data map[string]interface{}
          jsonResponse, jsonErr := json.Marshal(response)
          if jsonErr == nil {
              json.Unmarshal(jsonResponse, &data)
              // Get scroll_token from response if exists and store it in parameters object
              if scrollToken, ok := data["scroll_token"]; ok {
                  p.SearchBaseParams.ScrollToken = fmt.Sprintf("%v", scrollToken)
              } else {
                  continueScrolling = false
                  fmt.Println("Unable to continue scrolling.")
              }
              // Add records retrieved to the records array
              allRecords = append(allRecords, response.Data...)
          }       
          batch++
          foundAllRecords = (len(allRecords) == response.Total)
          time.Sleep(6 * time.Second) // Avoid hitting rate limit thresholds
      }
      
      // Calculate time required to process batches
      endTime := time.Now()
      runtime := endTime.Sub(startTime).Seconds()
          
      fmt.Printf("Successfully recovered %d profiles in %d batches [%d seconds].\n",
                 len(allRecords), batch, (int) (math.Round((float64) (runtime))))
      
      // Use utility function to save profiles to CSV    
      csvHeaderFields := []string{"work_email", "full_name", "linkedin_url",
                                  "job_title", "job_company_name"}
      csvFilename := "all_employee_profiles.csv"
      saveProfilesToCsv(allRecords, csvFilename, csvHeaderFields, ",")
  }

  // Save profiles to CSV (utility function)
  func saveProfilesToCsv(profiles []pdlmodel.Person, filename string, fields []string, delim string) {
      // Define header fields
      if fields == nil && len(profiles) > 0 {
          e := reflect.ValueOf(&(profiles[0])).Elem()
          for i := 0; i < e.NumField(); i++ {
              fields = append(fields, e.Type().Field(i).Name)
          }
      }
      
      // Write CSV file
      csvFile, err := os.Create(filename)
      if err == nil {
          csvwriter := csv.NewWriter(csvFile)
          defer csvwriter.Flush()
          // Write header
          csvwriter.Write(fields)
          // Write body
          count := 0
          for i := range profiles {
              var data map[string]interface{}
              jsonResponse, jsonErr := json.Marshal(profiles[i])
              if jsonErr == nil {
                  json.Unmarshal(jsonResponse, &data)
                  var record []string
                  for j := range fields {
                      record = append(record, fmt.Sprintf("%v", data[fields[j]]))
                  }
                  csvwriter.Write(record)
                  count++
              }
          }
          fmt.Printf("Wrote %d lines to: %s.\n", count, filename)
      }
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  import requests, json, time, csv

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Limit the number of records to pull (to prevent accidentally using 
  # more credits than expected when testing out this code).
  MAX_NUM_RECORDS_LIMIT = 150 # The maximum number of records to retrieve
  USE_MAX_NUM_RECORDS_LIMIT = True # Set to False to pull all available records

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an Elasticsearch query
  ES_QUERY = {
    "query": {
      "bool": {
          "must": [
              {"term": {"job_company_name": "amazon"}}
        ]
      }
    }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': json.dumps(ES_QUERY),
    'size': 100, 
    'pretty': True
  }

  # Pull all results in multiple batches
  batch = 1
  # Store all records retreived in an array
  all_records = []
  # Time the process
  start_time = time.time()
  found_all_records = False
  continue_scrolling = True

  # While still scrolling through data and still records to be found
  while continue_scrolling and not found_all_records: 

    # Check if we reached the maximum number of records we want
    if USE_MAX_NUM_RECORDS_LIMIT:
      num_records_to_request = MAX_NUM_RECORDS_LIMIT - len(all_records)
      # Adjust size parameter
      PARAMS['size'] = max(0, min(100, num_records_to_request))
      # Check if MAX_NUM_RECORDS_LIMIT reached
      if num_records_to_request == 0:
        print(f"Stopping - reached maximum number of records to pull "
              f"[MAX_NUM_RECORDS_LIMIT = {MAX_NUM_RECORDS_LIMIT}].")
        break

    # Pass the parameters object to the Person Search API
    response = requests.get(
      PDL_URL,
      headers=HEADERS,
      params=PARAMS
    ).json()

    # Check for successful response
    if response['status'] == 200:
      # Add records retrieved to the records array
      all_records.extend(response['data'])
      print(f"Retrieved {len(response['data'])} records in batch {batch} "
            f"- {response['total'] - len(all_records)} records remaining.")
    else:
      print(f"Error retrieving some records:\n\t"
            f"[{response['status']} - {response['error']['type']}] "
            f"{response['error']['message']}")
    
    # Get scroll_token from response if exists and store it in parameters object
    if 'scroll_token' in response:
      PARAMS['scroll_token'] = response['scroll_token']
    else:
      continue_scrolling = False
      print(f"Unable to continue scrolling.")

    batch += 1
    found_all_records = (len(all_records) == response['total'])
    time.sleep(6) # avoid hitting rate limit thresholds
   
  # Calculate time required to process batches
  end_time = time.time()
  runtime = end_time - start_time
          
  print(f"Successfully recovered {len(all_records)} profiles in "
        f"{batch} batches [{round(runtime, 2)} seconds].")

  # Save profiles to CSV (utility function)
  def save_profiles_to_csv(profiles, filename, fields=[], delim=','):
    # Define header fields
    if fields == [] and len(profiles) > 0:
        fields = profiles[0].keys()
    # Write CSV file
    with open(filename, 'w') as csvfile:
      writer = csv.writer(csvfile, delimiter=delim)
      # Write header
      writer.writerow(fields)
      # Write body
      count = 0
      for profile in profiles:
        writer.writerow([ profile[field] for field in fields ])
        count += 1
    print(f"Wrote {count} lines to: '{filename}'.")

  # Use utility function to save profiles to CSV    
  csv_header_fields = ['work_email', 'full_name', "linkedin_url",
                       'job_title', 'job_company_name']
  csv_filename = "all_employee_profiles.csv"
  save_profiles_to_csv(all_records, csv_filename, csv_header_fields)
  ```

  ```python Python3 (SQL) expandable theme={null}
  import requests, json, time, csv

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Limit the number of records to pull (to prevent accidentally using 
  # more credits than expected when testing out this code).
  MAX_NUM_RECORDS_LIMIT = 150 # The maximum number of records to retrieve
  USE_MAX_NUM_RECORDS_LIMIT = True # Set to False to pull all available records

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create an SQL query
  SQL_QUERY = \
  """
   SELECT * FROM person
   WHERE job_company_name='amazon';
  """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 100, 
    'pretty': True
  }

  # Pull all results in multiple batches
  batch = 1
  # Store all records retreived in an array
  all_records = []
  # Time the process
  start_time = time.time()
  found_all_records = False
  continue_scrolling = True

  # While still scrolling through data and still records to be found
  while continue_scrolling and not found_all_records: 

    # Check if we reached the maximum number of records we want
    if USE_MAX_NUM_RECORDS_LIMIT:
      num_records_to_request = MAX_NUM_RECORDS_LIMIT - len(all_records)
      # Adjust size parameter
      PARAMS['size'] = max(0, min(100, num_records_to_request))
      # Check if MAX_NUM_RECORDS_LIMIT reached
      if num_records_to_request == 0:
        print(f"Stopping - reached maximum number of records to pull "
              f"[MAX_NUM_RECORDS_LIMIT = {MAX_NUM_RECORDS_LIMIT}].")
        break

    # Pass the parameters object to the Person Search API
    response = requests.get(
      PDL_URL,
      headers=HEADERS,
      params=PARAMS
    ).json()

    # Check for successful response
    if response['status'] == 200:
      # Add records retrieved to the records array
      all_records.extend(response['data'])
      print(f"Retrieved {len(response['data'])} records in batch {batch} "
            f"- {response['total'] - len(all_records)} records remaining.")
    else:
      print(f"Error retrieving some records:\n\t"
            f"[{response['status']} - {response['error']['type']}] "
            f"{response['error']['message']}")
    
    # Get scroll_token from response if exists and store it in parameters object
    if 'scroll_token' in response:
      PARAMS['scroll_token'] = response['scroll_token']
    else:
      continue_scrolling = False
      print(f"Unable to continue scrolling.")

    batch += 1
    found_all_records = (len(all_records) == response['total'])
    time.sleep(6) # avoid hitting rate limit thresholds
   
  # Calculate time required to process batches
  end_time = time.time()
  runtime = end_time - start_time
          
  print(f"Successfully recovered {len(all_records)} profiles in "
        f"{batch} batches [{round(runtime, 2)} seconds].")

  # Save profiles to CSV (utility function)
  def save_profiles_to_csv(profiles, filename, fields=[], delim=','):
    # Define header fields
    if fields == [] and len(profiles) > 0:
        fields = profiles[0].keys()
    # Write CSV file
    with open(filename, 'w') as csvfile:
      writer = csv.writer(csvfile, delimiter=delim)
      # Write header
      writer.writerow(fields)
      # Write body
      count = 0
      for profile in profiles:
        writer.writerow([ profile[field] for field in fields ])
        count += 1
    print(f"Wrote {count} lines to: '{filename}'.")

  # Use utility function to save profiles to CSV    
  csv_header_fields = ['work_email', 'full_name', "linkedin_url",
                       'job_title', 'job_company_name']
  csv_filename = "all_employee_profiles.csv"
  save_profiles_to_csv(all_records, csv_filename, csv_header_fields)
  ```
</CodeGroup>

## Sales Prospecting

*"I want to email engineering leaders at stripe.com, plaid.com, xignite.com and square.com, so that I can reach out to them about my product."*

<CodeGroup>
  ```python Python3 SDK (Elasticsearch) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a list of company domains to search against
  DESIRED_COMPANY_DOMAINS = [
    'stripe.com', 'plaid.com', 'xignite.com', 'square.com'
  ]

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an Elasticsearch query
  ES_QUERY = {
      "query": {
          "bool": {
          "must": [
          {"terms": {"job_company_website": DESIRED_COMPANY_DOMAINS}},
          {"term": {"job_title_role": "engineering"}},
          {"terms": {"job_title_levels": ["vp", "director", "manager"]}},
          {"exists": {"field": "work_email"}}
        ]
      }
      }
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': ES_QUERY,
    'size': 100
  }

  # Pass the parameters object to the Person Search API
  response = CLIENT.person.search(**PARAMS).json()

  # Check for successful response
  if response["status"] == 200:
    for record in response['data']:
      # Print selected fields
      print(
        record['work_email'],
        record['full_name'],
        record['job_title'],
        record['job_company_name']
      )

    print(f"Successfully grabbed {len(response['data'])} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The eager beaver was not so eager. See error and try again.")
    print("error:", response)
  ```

  ```python Python3 SDK (SQL) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a list of company domains to search against
  DESIRED_COMPANY_DOMAINS = [
    'stripe.com', 'plaid.com', 'xignite.com', 'square.com'
  ]

  # Create a string representation of the list
  COMPANY_DOMAINS_STRING_REP = ", ".join(
    (f"'{site}'" for site in DESIRED_COMPANY_DOMAINS)
  )

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create an SQL query
  SQL_QUERY = \
  f"""
    SELECT * FROM person
    WHERE job_company_website IN ({COMPANY_DOMAINS_STRING_REP})
    AND job_title_role='engineering'
    AND job_title_levels IN ('vp', 'director', 'manager')
    AND work_email IS NOT NULL;
  """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 100
  }

  # Pass the parameters object to the Person Search API
  response = CLIENT.person.search(**PARAMS).json()

  # Check for successful response
  if response["status"] == 200:
    for record in response['data']:
      # Print selected fields
      print(
        record['work_email'],
        record['full_name'],
        record['job_title'],
        record['job_company_name']
      )

    print(f"Successfully grabbed {len(response['data'])} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The eager beaver was not so eager. See error and try again.")
    print("error:", response)
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create a list of company domains to search against
  const desiredCompanyDomains = [
      "stripe.com", "plaid.com", "xignite.com", "square.com"
  ];

  // Create an Elasticsearch query
  const esQuery = {
    query: {
      bool: {
        must:[
          {terms: {job_company_website: desiredCompanyDomains}}, 
          {term: {job_title_role: "engineering"}}, 
          {terms: {job_title_levels: ["vp", "director", "manager"]}}, 
          {exists: {field: "work_email"}} 
        ]
      }
    }
  }

  // Create a parameters JSON object
  const params = {
    searchQuery: esQuery, 
    size: 100
  }

  // Pass the current parameters object to the Person Search API
  PDLJSClient.person.search.elastic(params).then((data) => {
      var record
      
      for (let response in data.data) {
      
          record = data.data[response]
        
          // Print selected fields
          console.log(
              record["work_email"],
              record["full_name"],
              record["job_title"],
              record["job_company_name"],
              )
      }
      console.log(`Successfully grabbed ${data.data.length} records from PDL.`);
      console.log(`${data["total"]} total PDL records exist matching this query.`)
  }).catch((error) => {
      console.log("NOTE: The eager beaver was not so eager. See error and try again.")
      console.log(error);
  });
  ```

  ```javascript JavaScript (SQL) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create a list of company domains to search against
  const desiredCompanyDomains = [
      "stripe.com", "plaid.com", "xignite.com", "square.com"
  ];

  // Create a string representation of the list
  var companyStringRep = "'" + desiredCompanyDomains.join("', '") + "'";

  // Create an SQL query
  const sqlQuery = `SELECT * FROM person
    WHERE job_company_website IN (${companyStringRep})
    AND job_title_role='engineering'
    AND job_title_levels IN ('vp', 'director', 'manager')
    AND work_email IS NOT NULL;`

  // Create a parameters JSON object
  const params = {
    searchQuery: sqlQuery, 
    size: 100
  }

  // Pass the current parameters object to the Person Search API
  PDLJSClient.person.search.sql(params).then((data) => {
      var record
      
      for (let response in data.data) {
      
          record = data.data[response]
        
          // Print selected fields
          console.log(
              record["work_email"],
              record["full_name"],
              record["job_title"],
              record["job_company_name"],
              )
      }
      console.log(`Successfully grabbed ${data.data.length} records from PDL.`);
      console.log(`${data["total"]} total PDL records exist matching this query.`)
  }).catch((error) => {
      console.log("NOTE: The eager beaver was not so eager. See error and try again.")
      console.log(error);
  });
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create a list of company domains to search against
  DESIRED_COMPANY_DOMAINS = [
    'stripe.com', 'plaid.com', 'xignite.com', 'square.com'
  ]

  # Create an Elasticsearch query
  ES_QUERY = {
      "query": {
          "bool": {
          "must": [
          {"terms": {"job_company_website": DESIRED_COMPANY_DOMAINS}},
          {"term": {"job_title_role": "engineering"}},
          {"terms": {"job_title_levels": ["vp", "director", "manager"]}},
          {"exists": {"field": "work_email"}}
        ]
      }
      }
  }

  # Pass parameters to the Person Search API
  response = Peopledatalabs::Search.person(searchType: 'elastic', query: ES_QUERY, size: 100)

  # Check for successful response
  if response['status'] == 200
      data = response['data']
      data.each do |record|
        # Print selected fields
        puts "#{record['work_email']} \
              #{record['full_name']} \
              #{record['job_title']} \
              #{record['job_company_name']}"
      end

      puts "Successfully grabbed #{data.length()} records from PDL."
      puts "#{response['total']} total PDL records exist matching this query."
  else
      puts "NOTE: The eager beaver was not so eager. See error and try again."
      puts "Error: #{response}"
  end
  ```

  ```ruby Ruby (SQL) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create a string of company domains to search against
  COMPANY_DOMAINS_STRING_REP = "'stripe.com', 'plaid.com', 'xignite.com', 'square.com'"

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE job_company_website IN (#{COMPANY_DOMAINS_STRING_REP})
    AND job_title_role='engineering'
    AND job_title_levels IN ('vp', 'director', 'manager')
    AND work_email IS NOT NULL;
  """

  # Pass parameters to the Person Search API
  response = Peopledatalabs::Search.person(searchType: 'sql', query: SQL_QUERY, size: 100)

  # Check for successful response
  if response['status'] == 200
      data = response['data']
      data.each do |record|
        # Print selected fields
        puts "#{record['work_email']} \
              #{record['full_name']} \
              #{record['job_title']} \
              #{record['job_company_name']}"
      end

      puts "Successfully grabbed #{data.length()} records from PDL."
      puts "#{response['total']} total PDL records exist matching this query."
  else
      puts "NOTE: The eager beaver was not so eager. See error and try again."
      puts "Error: #{response}"
  end
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create a list of company domains to search against
      desiredCompanyDomains := []string{"stripe.com", "plaid.com", "xignite.com", "square.com"}
      
      // Create an Elasticsearch query
      elasticSearchQuery := map[string]interface{} {
          "query": map[string]interface{} {
              "bool": map[string]interface{} {
                  "must": []map[string]interface{} {
                      {"terms": map[string]interface{}{"job_company_website": desiredCompanyDomains}},
                      {"term": map[string]interface{}{"job_title_role": "engineering"}},
                      {"terms": map[string]interface{}{"job_title_levels": []string{"vp", "director", "manager"}}},
                      {"exists": map[string]interface{}{"field": "work_email"}},
                  },
              },
          },
      }

      // Create a parameters JSON object
      params := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 100,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              Query: elasticSearchQuery,
          },
      }

      // Pass the parameters object to the Person Search API
      response, err := client.Person.Search(context.Background(), params)
      
      // Check for successful response
      if err == nil {
          for i := range response.Data {
              record := response.Data[i]
              // Print selected fields
              fmt.Println(record.WorkEmail, record.FullName, record.JobTitle, record.JobCompanyName)
          }
          
          fmt.Printf("Successfully grabbed %d records from PDL.\n", len(response.Data))
          fmt.Printf("%d total PDL records exist matching this query.\n", response.Total)
     	} else {
          fmt.Println("NOTE: The eager beaver was not so eager. See error and try again.")
          fmt.Println("error:", err)
      }
  }
  ```

  ```go Go (SQL) expandable theme={null}
  package main

  import (
      "fmt"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create a string of company domains to search against
      companyDomainsStringRep := "'stripe.com', 'plaid.com', 'xignite.com', 'square.com'"
      
      // Create an SQL query
      sqlQuery := "SELECT * FROM person" +
      " WHERE job_company_website IN (" + companyDomainsStringRep + ")" +
          " AND job_title_role='engineering'" +
          " AND job_title_levels IN ('vp', 'director', 'manager')" +
          " AND work_email IS NOT NULL;"

      // Create a parameters JSON object
      params := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 100,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              SQL: sqlQuery,
          },
      }

      // Pass the parameters object to the Person Search API
      response, err := client.Person.Search(context.Background(), params)
      
      // Check for successful response
      if err == nil {
          for i := range response.Data {
              record := response.Data[i]
              // Print selected fields
              fmt.Println(record.WorkEmail, record.FullName, record.JobTitle, record.JobCompanyName)
          }
          
          fmt.Printf("Successfully grabbed %d records from PDL.\n", len(response.Data))
          fmt.Printf("%d total PDL records exist matching this query.\n", response.Total)
     	} else {
          fmt.Println("NOTE: The eager beaver was not so eager. See error and try again.")
          fmt.Println("error:", err)
      }
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create a list of company domains to search against
  DESIRED_COMPANY_DOMAINS = [
    'stripe.com', 'plaid.com', 'xignite.com', 'square.com'
  ]

  # https://pdl-prod-schema.s3-us-west-2.amazonaws.com/15.0/enums/job_title_levels.txt
  # for enumerated possible values of job_title_levels

  # Create an Elasticsearch query
  ES_QUERY = {
  	"query": {
  		"bool": {
      	"must": [
        	{"terms": {"job_company_website": DESIRED_COMPANY_DOMAINS}},
          {"term": {"job_title_role": "engineering"}},
          {"terms": {"job_title_levels": ["vp", "director", "manager"]}},
          {"exists": {"field": "work_email"}}
        ]
      }
  	}
  }

  # Create a parameters JSON object
  PARAMS = {
    'query': json.dumps(ES_QUERY),
    'size': 100
  }

  # Pass the parameters object to the Person Search API
  response = requests.get(
    PDL_URL,
    headers=HEADERS,
    params=PARAMS
  ).json()

  # Check for successful response
  if response["status"] == 200:
    for record in response['data']:
      # Print selected fields
      print(
        record['work_email'],
        record['full_name'],
        record['job_title'],
        record['job_company_name']
      )

    print(f"Successfully grabbed {len(response['data'])} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The eager beaver was not so eager. See error and try again.")
    print("error:", response)
  ```

  ```python Python3 (SQL) expandable theme={null}
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Create a list of company domains to search against
  DESIRED_COMPANY_DOMAINS = [
    'stripe.com', 'plaid.com', 'xignite.com', 'square.com'
  ]

  # Create a string representation of the list
  COMPANY_DOMAINS_STRING_REP = ", ".join(
    (f"'{site}'" for site in DESIRED_COMPANY_DOMAINS)
  )

  # https://pdl-prod-schema.s3-us-west-2.amazonaws.com/15.0/job_title_levels.txt
  # for enumerated possible values of job_title_levels

  # Create an SQL query
  SQL_QUERY = \
  f"""
    SELECT * FROM person
    WHERE job_company_website IN ({COMPANY_DOMAINS_STRING_REP})
    AND job_title_role='engineering'
    AND job_title_levels IN ('vp', 'director', 'manager')
    AND work_email IS NOT NULL;
  """

  # Create a parameters JSON object
  PARAMS = {
    'sql': SQL_QUERY,
    'size': 100
  }

  # Pass the parameters object to the Person Search API
  response = requests.get(
    PDL_URL,
    headers=HEADERS,
    params=PARAMS
  ).json()

  # Check for successful response
  if response["status"] == 200:
    
    for record in response['data']:
      # Print selected fields
      print(
        record['work_email'],
        record['full_name'],
        record['job_title'],
        record['job_company_name']
      )

    print(f"Successfully grabbed {len(response['data'])} records from PDL.")
    print(f"{response['total']} total PDL records exist matching this query.")
  else:
    print("NOTE: The eager beaver was not so eager. See error and try again.")
    print("error:", response)
  ```
</CodeGroup>

## Recruiting

*"I have a client looking for marketing managers and dishwashers in Oregon but NOT in portland (don't ask why). They want to reach out to them on LinkedIn, so they asked that each candidate have a LinkedIn URL. I want as many people as PDL can give me matching this criteria."*

<CodeGroup>
  ```python Python3 SDK (Elasticsearch) expandable theme={null}
  from time import sleep
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Run Person searches in batches with 6-second intervals 
  def get_all_pdl_records_es(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'query': query,
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = CLIENT.person.search(**params).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  if __name__ == '__main__':
      # Create an Elasticsearch query
      ES_QUERY = {
          "query": {
          "bool": {
          "must": [
              {"term": {"location_region": "oregon"}},
              {"bool": {
              "should": [
                  {"match": {"job_title": "dishwasher"}},
                  {"bool": {
                  "must": [
                      {"term": {"job_title_role": "marketing"}},
                      {"term": {"job_title_levels": "manager"}}
                  ]
                  }}
              ]
              }
              },
          {"exists": {"field": "linkedin_url"}}
         ],
         "must_not":[
            {"term": {"location_locality": "portland"}},
         ]
          }
      }
      }

      # Find all records matching query
      recruiting_leads = get_all_pdl_records_es(ES_QUERY)
              
      print(f"Got {len(recruiting_leads)} recruiting leads for my wealthy client!")

      #GO make_money_with_data(recruiting_leads)!
  ```

  ```python Python3 SDK (SQL) expandable theme={null}
  from time import sleep
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Run Person searches in batches with 6-second intervals 
  def get_all_pdl_records_sql(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'sql': query,
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = CLIENT.person.search(**params).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  # Create an SQL query
  SQL_QUERY = \
    """
      SELECT * FROM person
      WHERE location_region='oregon'
      AND NOT location_locality='portland'
      AND (
        job_title LIKE '%dishwasher%'
        OR (
          job_title_role='marketing'
          AND job_title_levels='manager'
        )
      )
      AND linkedin_url IS NOT NULL;
    """

  # Find all records matching query
  recruiting_leads = get_all_pdl_records_sql(SQL_QUERY)
              
  print(f"Got {len(recruiting_leads)} recruiting leads for my wealthy client!")

  #GO make_money_with_data(recruiting_leads)!
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an Elasticsearch query
  const esQuery = {
      "query": {
      "bool": {
      "must": [
          {"term": {"location_region": "oregon"}},
          {"bool": {
          "should": [
              {"match": {"job_title": "dishwasher"}},
              {"bool": {
              "must": [
                  {"term": {"job_title_role": "marketing"}},
                  {"term": {"job_title_levels": "manager"}}
              ]
              }}
          ]
          }
          },
          {"exists": {"field": "linkedin_url"}}
     ],
     "must_not":[
        {"term": {"location_locality": "portland"}},
     ]
     }
     }
  }

  // Store all records retreived in an array
  var allRecords = [];
  // The current scroll_token
  var scrollToken = null;
  var pageSize = 100;
  var batch = 1;

  // Create a parameters JSON object
  var params = {
      searchQuery: esQuery, 
      size: pageSize,
      scroll_token: null,
      dataset: "all"
  }

  // Run batches recursively
  runBatch();

  // Run Person searches in batches
  function runBatch() {

      // Store current scroll_token in parameters object
      params.scroll_token = scrollToken;
      // Pass the current parameters object to the Person Search API
      PDLJSClient.person.search.elastic(params).then((data) => {
          // Add records retrieved to the records array
          Array.prototype.push.apply(allRecords, data.data);
          
          // Store scroll_token from response
          scrollToken = data['scroll_token'];
          
          console.log(`Batch ${batch} success!`);
          batch++;
          
          // Run searches in batches with 6-second intervals 
          if (scrollToken) {
              setTimeout(function() {
                  runBatch(params);
              }, 6000);
          }
      }).catch((error) => {
          console.log("Unable to continue scrolling.");
          console.log("Done!");
          console.log(`Got ${allRecords.length} recruiting leads for my wealthy client!`);
      });
  }
  ```

  ```javascript JavaScript (SQL) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an SQL query
  const sqlQuery = `SELECT * FROM person
      WHERE location_region='oregon'
      AND NOT location_locality='portland'
      AND (
        job_title LIKE '%dishwasher%'
        OR (
          job_title_role='marketing'
          AND job_title_levels='manager'
        )
      )
      AND linkedin_url IS NOT NULL;`;

  // Store all records retreived in an array
  var allRecords = [];
  // The current scroll_token
  var scrollToken = null;
  var pageSize = 100;
  var batch = 1;

  // Create a parameters JSON object
  var params = {
      searchQuery: sqlQuery, 
      size: pageSize,
      scroll_token: null,
      dataset: "all"
  }

  // Run batches recursively
  runBatch();

  // Run Person searches in batches
  function runBatch() {

      // Store current scroll_token in parameters object
      params.scroll_token = scrollToken;
      // Pass the current parameters object to the Person Search API
      PDLJSClient.person.search.sql(params).then((data) => {
          // Add records retrieved to the records array
          Array.prototype.push.apply(allRecords, data.data);
          
          // Store scroll_token from response
          scrollToken = data['scroll_token'];
          
          console.log(`Batch ${batch} success!`);
          batch++;
          
          // Run searches in batches with 6-second intervals
          if (scrollToken) {
              setTimeout(function() {
                  runBatch(params);
              }, 6000);
          }
      }).catch((error) => {
          console.log("Unable to continue scrolling.");
          console.log("Done!");
          console.log(`Got ${allRecords.length} recruiting leads for my wealthy client!`);
      });
  }
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  PAGE_SIZE = 100

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_es(query)

      # Store all records retreived in an array
      all_records = []
      batch = 1
      # The current scroll_token
      scroll_token = {}

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 || !scroll_token.nil?

          # Pass parameters to the Person Search API
          response = Peopledatalabs::Search.person(searchType: 'elastic', query: query, size: PAGE_SIZE, scroll_token: scroll_token, dataset: "all")
  				
          # Check for successful response
          if response['status'] == 200
            # Add records retrieved to the records array
            all_records += response['data']
            # Store the scroll_token for next batch
            scroll_token = response['scroll_token']

            puts "Batch #{batch} success!"
            sleep(6)
            batch += 1
            
          else
            puts "Unable to continue scrolling."
            break
          end
      end
      
      puts "Done!"

      return all_records
  end

  # Create an Elasticsearch query
  ES_QUERY = {
      "query": {
      "bool": {
      "must": [
          {"term": {"location_region": "oregon"}},
          {"bool": {
          "should": [
              {"match": {"job_title": "dishwasher"}},
              {"bool": {
              "must": [
                  {"term": {"job_title_role": "marketing"}},
                  {"term": {"job_title_levels": "manager"}}
              ]
              }}
          ]
          }
          },
      {"exists": {"field": "linkedin_url"}}
     ],
     "must_not":[
        {"term": {"location_locality": "portland"}},
     ]
      }
  }
  }

  # Find all records matching query
  recruiting_leads = get_all_pdl_records_es(ES_QUERY)
              
  puts "Got #{recruiting_leads.length()} recruiting leads for my wealthy client!"

  #GO make_money_with_data(recruiting_leads)!
  ```

  ```ruby Ruby (SQL) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  PAGE_SIZE = 100

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_sql(query)

      # Store all records retreived in an array
      all_records = []
      batch = 1
      # The current scroll_token
      scroll_token = {}

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 || !scroll_token.nil?

          # Pass parameters to the Person Search API
          response = Peopledatalabs::Search.person(searchType: 'sql', query: query, size: PAGE_SIZE, scroll_token: scroll_token, dataset: "all")
  				
          # Check for successful response
          if response['status'] == 200
            # Add records retrieved to the records array
            all_records += response['data']
            # Store the scroll_token for next batch
            scroll_token = response['scroll_token']

            puts "Batch #{batch} success!"
            sleep(6)
            batch += 1
            
          else
            puts "Unable to continue scrolling."
            break
          end
      end
      
      puts "Done!"

      return all_records
  end

  # Create an SQL query
  SQL_QUERY = \
    """
      SELECT * FROM person
      WHERE location_region='oregon'
      AND NOT location_locality='portland'
      AND (
        job_title LIKE '%dishwasher%'
        OR (
          job_title_role='marketing'
          AND job_title_levels='manager'
        )
      )
      AND linkedin_url IS NOT NULL;
    """

  # Find all records matching query
  recruiting_leads = get_all_pdl_records_sql(SQL_QUERY)
              
  puts "Got #{recruiting_leads.length()} recruiting leads for my wealthy client!"

  #GO make_money_with_data(recruiting_leads)!
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "time"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Create an Elasticsearch query
      elasticSearchQuery := map[string]interface{} {
          "query": map[string]interface{} {
              "bool": map[string]interface{} {
                  "must": []map[string]interface{} {
                      {"term": map[string]interface{} {"location_region": "oregon"}},
                      {"bool": map[string]interface{} {
                      "should": []map[string]interface{} {
                          {"match": map[string]interface{} {"job_title": "dishwasher"}},
                          {"bool": map[string]interface{} {
                              "must": []map[string]interface{} {
                                  {"term": map[string]interface{} {"job_title_role": "marketing"}},
                                  {"term": map[string]interface{} {"job_title_levels": "manager"}},
                              },
                          },
                          },
                      },
                      },
                      },
                      {"exists": map[string]interface{} {"field": "linkedin_url"}},
                  },
                  "must_not": []map[string]interface{} {
                      {"term": map[string]interface{} {"location_locality": "portland"}},
                  },
              },
          },
      }

      // Find all records matching query
      recruitingLeads := getAllPdlRecordsEs(elasticSearchQuery)
      fmt.Printf("Got %d recruiting leads for my wealthy client!\n", len(recruitingLeads))
      
      //GO make_money_with_data(recruiting_leads)!
  }

  // Run Person searches in batches with 6-second intervals
  func getAllPdlRecordsEs(query interface{}) []pdlmodel.Person {
      // Store all records retreived in an array
      var allRecords []pdlmodel.Person
      batch := 1
      // The current scroll_token
      var scrollToken string
      const pageSize = 100    
          
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create a parameters JSON object
      p := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: pageSize,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              Query: query,
              ScrollToken: scrollToken,
              Dataset: "all",
          },
      }
      
      // Keep retrieving records until unable to continue scrolling
      for batch == 1 || scrollToken != "" {
          // Pass the parameters object to the Person Search API
          response, err := client.Person.Search(context.Background(), p)
          
          // Check for successful response
          if err == nil {
              // Add records retrieved to the records array
              allRecords = append(allRecords, response.Data...)
              // Store scroll_token from response
              p.SearchBaseParams.ScrollToken, scrollToken = response.ScrollToken, response.ScrollToken
              
              fmt.Printf("Batch %d success!\n", batch)
              time.Sleep(6 * time.Second)
              batch++
          } else {
              fmt.Println("Unable to continue scrolling.")
              break
          }
      }
      fmt.Println("Done!")
          
      return allRecords
  }
  ```

  ```go Go (SQL) expandable theme={null}
  package main

  import (
      "fmt"
      "time"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Create an SQL query
      sqlQuery := "SELECT * FROM person" +
          " WHERE location_region='oregon'" +
          " AND NOT location_locality='portland'" +
          " AND (" +
          "   job_title LIKE '%dishwasher%'" +
          "   OR (" +
          "     job_title_role='marketing'" +
          "     AND job_title_levels='manager'" +
          "   )" +
          " )" +
          " AND linkedin_url IS NOT NULL;"

      // Find all records matching query
      recruitingLeads := getAllPdlRecordsEs(sqlQuery)
      fmt.Printf("Got %d recruiting leads for my wealthy client!\n", len(recruitingLeads))
      
      //GO make_money_with_data(recruiting_leads)!
  }

  // Run Person searches in batches with 6-second intervals
  func getAllPdlRecordsEs(query string) []pdlmodel.Person {
      // Store all records retreived in an array
      var allRecords []pdlmodel.Person
      batch := 1
      // The current scroll_token
      var scrollToken string
      const pageSize = 100    
          
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create a parameters JSON object
      p := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: pageSize,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              SQL: query,
              ScrollToken: scrollToken,
              Dataset: "all",
          },
      }
      
      // Keep retrieving records until unable to continue scrolling
      for batch == 1 || scrollToken != "" {
          // Pass the parameters object to the Person Search API
          response, err := client.Person.Search(context.Background(), p)
          
          // Check for successful response
          if err == nil {
              // Add records retrieved to the records array
              allRecords = append(allRecords, response.Data...)
              // Store scroll_token from response
              p.SearchBaseParams.ScrollToken, scrollToken = response.ScrollToken, response.ScrollToken
              
              fmt.Printf("Batch %d success!\n", batch)
              time.Sleep(6 * time.Second)
              batch++
          } else {
              fmt.Println("Unable to continue scrolling.")
              break
          }
      }
      fmt.Println("Done!")
          
      return allRecords
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  from time import sleep
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_es(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'query': json.dumps(query),
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = requests.get(
              PDL_URL,
              headers=HEADERS,
              params=params
          ).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  if __name__ == '__main__':
      # Create an Elasticsearch query
      ES_QUERY = {
          "query": {
          "bool": {
          "must": [
              {"term": {"location_region": "oregon"}},
              {"bool": {
              "should": [
                  {"match": {"job_title": "dishwasher"}},
                  {"bool": {
                  "must": [
                      {"term": {"job_title_role": "marketing"}},
                      {"term": {"job_title_levels": "manager"}}
                  ]
                  }}
              ]
              }
              },
          {"exists": {"field": "linkedin_url"}}
         ],
         "must_not":[
            {"term": {"location_locality": "portland"}},
         ]
          }
      }
      }

      # Find all records matching query
      recruiting_leads = get_all_pdl_records_es(ES_QUERY)
              
      print(f"Got {len(recruiting_leads)} recruiting leads for my wealthy client!")

      #GO make_money_with_data(recruiting_leads)!
  ```

  ```python Python3 (SQL) expandable theme={null}
  from time import sleep 
  import requests

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_sql(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'sql': query,
          'size': PAGE_SIZE,
        	'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = requests.get(
              PDL_URL,
              headers=HEADERS,
              params=params
          ).json()

          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
          batch += 1
      
      print("Done!")

      return all_records

  # Create an SQL query
  SQL_QUERY = \
    """
      SELECT * FROM person
      WHERE location_region='oregon'
      AND NOT location_locality='portland'
      AND (
        job_title LIKE '%dishwasher%'
        OR (
          job_title_role='marketing'
          AND job_title_levels='manager'
        )
      )
      AND linkedin_url IS NOT NULL;
    """

  # Find all records matching query
  recruiting_leads = get_all_pdl_records_sql(SQL_QUERY)

  print(f"got {len(recruiting_leads)} recruiting leads for my wealthy client!")

  #GO make_money_with_data(recruiting_leads)!
  ```
</CodeGroup>

## Ads

*"I want to sell yachts to rich people through ads on [Facebook](https://www.facebook.com/business/help/170456843145568?id=2469097953376494)."*

<CodeGroup>
  ```python Python3 SDK (Elasticsearch) expandable theme={null}
  from time import sleep
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_es(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'query': query,
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = CLIENT.person.search(**params).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  if __name__ == '__main__':
      # Create an Elasticsearch query
      ES_QUERY = {
  	   "query": {
             "bool": {
                 "must": [
                      {"exists": {"field": "facebook_id"}},
                      {"prefix": {"interests": "yacht"}},
                      {"term": {"inferred_salary": ">250,000"}}
                  ]
              }
          }
      }

      # Find all records matching query
      rich_yacht_people = get_all_pdl_records_es(ES_QUERY)
              
      print(f"Got {len(rich_yacht_people)} rich yacht people for my wealthy client!")

      #GO make_money_with_data(rich_yacht_people)!
  ```

  ```python Python3 SDK (SQL) expandable theme={null}
  from time import sleep
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_sql(query):
      #runs search in batches with 6 second intervals 

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'sql': query,
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = CLIENT.person.search(**params).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE facebook_id IS NOT NULL
    AND interests LIKE 'yacht%'
    AND inferred_salary='>250,000';
  """

  # Find all records matching query
  rich_yacht_people = get_all_pdl_records_sql(SQL_QUERY)

  print(f"got {len(rich_yacht_people)} rich yacht people for my wealthy client!")

  #GO make_money_with_data(rich_yacht_people)
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an Elasticsearch query
  const esQuery = {
  	   "query": {
             "bool": {
                 "must": [
                      {"exists": {"field": "facebook_id"}},
                      {"prefix": {"interests": "yacht"}},
                      {"term": {"inferred_salary": ">250,000"}}
                  ]
              }
          }
  }

  // Store all records retreived in an array
  var allRecords = [];
  // The current scroll_token
  var scrollToken = null;
  var pageSize = 100;
  var batch = 1;

  // Create a parameters JSON object
  var params = {
      searchQuery: esQuery, 
      size: pageSize,
      scroll_token: null,
      dataset: "all"
  }

  // Run batches recursively
  runBatch();

  // Run Person searches in batches
  function runBatch() {

      // Store current scroll_token in parameters object
      params.scroll_token = scrollToken;
      // Pass the current parameters object to the Person Search API
      PDLJSClient.person.search.elastic(params).then((data) => {
          // Add records retrieved to the records array
          Array.prototype.push.apply(allRecords, data.data);
          
          // Store scroll_token from response
          scrollToken = data['scroll_token'];
          
          console.log(`Batch ${batch} success!`);
          batch++;
          
          // Run searches in batches with 6-second intervals  
          if (scrollToken) {
              setTimeout(function() {
                  runBatch(params);
              }, 6000);
          }
      }).catch((error) => {
          console.log("Unable to continue scrolling.");
          console.log("Done!");
          console.log(`Got ${allRecords.length} rich yacht people for my wealthy client!`);
      });
  }
  ```

  ```javascript JavaScript (SQL) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an SQL query
  const sqlQuery = `SELECT * FROM person
                      WHERE facebook_id IS NOT NULL
                      AND interests LIKE 'yacht%'
                      AND inferred_salary='>250,000';`;

  // Store all records retreived in an array
  var allRecords = [];
  // The current scroll_token
  var scrollToken = null;
  var pageSize = 100;
  var batch = 1;

  // Create a parameters JSON object
  var params = {
      searchQuery: sqlQuery, 
      size: pageSize,
      scroll_token: null,
      dataset: "all"
  }

  // Run batches recursively
  runBatch();

  // Run Person searches in batches
  function runBatch() {

      // Store current scroll_token in parameters object
      params.scroll_token = scrollToken;
      // Pass the current parameters object to the Person Search API
      PDLJSClient.person.search.sql(params).then((data) => {
          // Add records retrieved to the records array
          Array.prototype.push.apply(allRecords, data.data);
          
          // Store scroll_token from response
          scrollToken = data['scroll_token'];
          
          console.log(`Batch ${batch} success!`);
          batch++;
          
          // Run searches in batches with 6-second intervals 
          if (scrollToken) {
              setTimeout(function() {
                  runBatch(params);
              }, 6000);
          }
      }).catch((error) => {
          console.log("Unable to continue scrolling.");
          console.log("Done!");
          console.log(`Got ${allRecords.length} rich yacht people for my wealthy client!`);
      });
  }
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  PAGE_SIZE = 100

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_es(query)

      # Store all records retreived in an array
      all_records = []
      batch = 1
      # The current scroll_token
      scroll_token = {}

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 || !scroll_token.nil?

          # Pass parameters to the Person Search API
          response = Peopledatalabs::Search.person(searchType: 'elastic', query: query, size: PAGE_SIZE, scroll_token: scroll_token, dataset: "all")
  				
          # Check for successful response
          if response['status'] == 200
            # Add records retrieved to the records array
            all_records += response['data']
            # Store the scroll_token for next batch
            scroll_token = response['scroll_token']

            puts "Batch #{batch} success!"
            sleep(6)
            batch += 1
            
          else
            puts "Unable to continue scrolling."
            break
          end
      end
      
      puts "Done!"

      return all_records
  end

  # Create an Elasticsearch query
  ES_QUERY = {
      "query": {
          "bool": {
             "must": [
                  {"exists": {"field": "facebook_id"}},
                  {"prefix": {"interests": "yacht"}},
                  {"term": {"inferred_salary": ">250,000"}}
              ]
          }
      }
  }

  # Find all records matching query
  rich_yacht_people = get_all_pdl_records_es(ES_QUERY)
              
  puts "Got #{rich_yacht_people.length()} rich yacht people for my wealthy client!"

  #GO make_money_with_data(rich_yacht_people)!
  ```

  ```ruby Ruby (SQL) expandable theme={null}
  require 'json'

  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  PAGE_SIZE = 100

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_sql(query)

      # Store all records retreived in an array
      all_records = []
      batch = 1
      # The current scroll_token
      scroll_token = {}

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 || !scroll_token.nil?

          # Pass parameters to the Person Search API
          response = Peopledatalabs::Search.person(searchType: 'sql', query: query, size: PAGE_SIZE, scroll_token: scroll_token, dataset: "all")
  				
          # Check for successful response
          if response['status'] == 200
            # Add records retrieved to the records array
            # Store the scroll_token for next batch
            all_records += response['data']
            scroll_token = response['scroll_token']

            puts "Batch #{batch} success!"
            sleep(6)
            batch += 1
            
          else
            puts "Unable to continue scrolling."
            break
          end
      end
      
      puts "Done!"

      return all_records
  end

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE facebook_id IS NOT NULL
    AND interests LIKE 'yacht%'
    AND inferred_salary='>250,000';
  """

  # Find all records matching query
  rich_yacht_people = get_all_pdl_records_sql(SQL_QUERY)
              
  puts "Got #{rich_yacht_people.length()} rich yacht people for my wealthy client!"

  #GO make_money_with_data(rich_yacht_people)!
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "time"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Create an Elasticsearch query
      elasticSearchQuery := map[string]interface{} {
          "query": map[string]interface{} {
              "bool": map[string]interface{} {
                  "must": []map[string]interface{} {
                      {"exists": map[string]interface{}{"field": "facebook_id"}},
                      {"prefix": map[string]interface{}{"interests": "yacht"}},
                      {"term": map[string]interface{}{"inferred_salary": ">250,000"}},
                  },
              },
          },
      }

      // Find all records matching query
      richYachtPeople := getAllPdlRecordsEs(elasticSearchQuery)
      fmt.Printf("Got %d rich yacht people for my wealthy client!\n", len(richYachtPeople))
      
      //GO make_money_with_data(rich_yacht_people)!
  }

  // Run Person searches in batches with 6-second intervals
  func getAllPdlRecordsEs(query interface{}) []pdlmodel.Person {
      // Store all records retreived in an array
      var allRecords []pdlmodel.Person
      batch := 1
      // The current scroll_token
      var scrollToken string
      const pageSize = 100    
          
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create a parameters JSON object
      p := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: pageSize,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              Query: query,
              ScrollToken: scrollToken,
              Dataset: "all",
          },
      }
      
      // Keep retrieving records until unable to continue scrolling
      for batch == 1 || scrollToken != "" {
          // Pass the parameters object to the Person Search API
          response, err := client.Person.Search(context.Background(), p)
          
          // Check for successful response
          if err == nil {
              // Add records retrieved to the records array
              allRecords = append(allRecords, response.Data...)
              // Store scroll_token from response
              p.SearchBaseParams.ScrollToken, scrollToken = response.ScrollToken, response.ScrollToken
              
              fmt.Printf("Batch %d success!\n", batch)
              time.Sleep(6 * time.Second)
              batch++
          } else {
              fmt.Println("Unable to continue scrolling.")
              break
          }
      }
      fmt.Println("Done!")
          
      return allRecords
  }
  ```

  ```go Go (SQL) expandable theme={null}
  package main

  import (
      "fmt"
      "time"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Create an SQL query
      sqlQuery := "SELECT * FROM person" +
          " WHERE facebook_id IS NOT NULL" +
          " AND interests LIKE 'yacht%'" +
          " AND inferred_salary='>250,000';"

      // Find all records matching query
      richYachtPeople := getAllPdlRecordsEs(sqlQuery)
      fmt.Printf("Got %d rich yacht people for my wealthy client!\n", len(richYachtPeople))
      
      //GO make_money_with_data(rich_yacht_people)!
  }

  // Run Person searches in batches with 6-second intervals
  func getAllPdlRecordsEs(query string) []pdlmodel.Person {
      // Store all records retreived in an array
      var allRecords []pdlmodel.Person
      batch := 1
      // The current scroll_token
      var scrollToken string
      const pageSize = 100    
          
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create a parameters JSON object
      p := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: pageSize,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              SQL: query,
              ScrollToken: scrollToken,
              Dataset: "all",
          },
      }
      
      // Keep retrieving records until unable to continue scrolling
      for batch == 1 || scrollToken != "" {
          // Pass the parameters object to the Person Search API
          response, err := client.Person.Search(context.Background(), p)
          
          // Check for successful response
          if err == nil {
              // Add records retrieved to the records array
              allRecords = append(allRecords, response.Data...)
              // Store scroll_token from response
              p.SearchBaseParams.ScrollToken, scrollToken = response.ScrollToken, response.ScrollToken
              
              fmt.Printf("Batch %d success!\n", batch)
              time.Sleep(6 * time.Second)
              batch++
          } else {
              fmt.Println("Unable to continue scrolling.")
              break
          }
      }
      fmt.Println("Done!")
          
      return allRecords
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  from time import sleep
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_es(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'query': json.dumps(query),
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = requests.get(
              PDL_URL,
              headers=HEADERS,
              params=params
          ).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  if __name__ == '__main__':
      # Create an Elasticsearch query
      ES_QUERY = {
  	   "query": {
             "bool": {
                 "must": [
                      {"exists": {"field": "facebook_id"}},
                      {"prefix": {"interests": "yacht"}},
                      {"term": {"inferred_salary": ">250,000"}}
                  ]
              }
          }
      }

      # Find all records matching query
      rich_yacht_people = get_all_pdl_records_es(ES_QUERY)
              
      print(f"Got {len(rich_yacht_people)} rich yacht people for my wealthy client!")

      #GO make_money_with_data(rich_yacht_people)!
  ```

  ```python Python3 (SQL) expandable theme={null}
  from time import sleep
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_sql(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'sql': query,
          'size': PAGE_SIZE,
        	'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = requests.get(
              PDL_URL,
              headers=HEADERS,
              params=params
          ).json()

          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE facebook_id IS NOT NULL
    AND interests LIKE 'yacht%'
    AND inferred_salary='>250,000';
  """

  # Find all records matching query
  rich_yacht_people = get_all_pdl_records_sql(SQL_QUERY)

  print(f"got {len(rich_yacht_people)} rich yacht people for my wealthy client!")

  #GO make_money_with_data(rich_yacht_people)
  ```
</CodeGroup>

## Customer Insights

*"I want information about my biggest customer ([Zenefits](http://www.zenefits.com).)"*

<CodeGroup>
  ```python Python3 SDK (Elasticsearch) expandable theme={null}
  from time import sleep
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_es(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'query': query,
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = CLIENT.person.search(**params).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  if __name__ == '__main__':
      # Create an Elasticsearch query
      ES_QUERY = {
          "query": {
              "term": {"job_company_website": "zenefits.com"}
          }
      }

      # Find all records matching query
      all_zenefits_employees = get_all_pdl_records_es(ES_QUERY)

      # Create aggregate objects
      skills_agg = {}
      titles_agg = {}
      schools_agg = {}
      other_companies_agg = {}

      # Iterate through records array for aggregation
      for record in all_zenefits_employees:
          # Aggregate skills
          for skill in record['skills']:
              skills_agg.setdefault(skill, 0)
              skills_agg[skill] += 1
          # Aggregate job titles
          if record['job_title']:
              titles_agg.setdefault(record['job_title'], 0)
              titles_agg[record['job_title']] += 1
          # Aggregate schools
          for edu in record['education']:
              if edu['school'] and edu['school']['type'] == "post-secondary institution":
                  schools_agg.setdefault(edu['school']['name'], 0)
                  schools_agg[edu['school']['name']] += 1
          # Aggregate other companies
          for exp in record['experience']:
              if exp['company'] and exp['company']['name'] != 'zenefits':
                  other_companies_agg.setdefault(exp['company']['name'], 0)
                  other_companies_agg[exp['company']['name']] += 1

      # Sort aggregate objects by count and print top 10 for each
      print("Top 10 skills for zenefits employees:")
      for skill, count in sorted(
          skills_agg.items(), key = lambda x: x[1], reverse=True
      )[:10]:
          print(count, skill)

      print("Top 10 titles for zenefits employees:")
      for title, count in sorted(
          titles_agg.items(), key = lambda x: x[1], reverse=True
      )[:10]:
          print(count, title)
   
      print("Top 10 universities for zenefits employees:")
      for school, count in sorted(
          schools_agg.items(), key = lambda x: x[1], reverse=True
      )[:10]:
          print(count, school)
    
      print("Top 10 former companies for zenefits employees:")
      for company, count in sorted(
          other_companies_agg.items(), key = lambda x: x[1], reverse=True
      )[:10]:
          print(count, company)
  ```

  ```python Python3 SDK (SQL) expandable theme={null}
  from time import sleep
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_sql(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'sql': query,
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = CLIENT.person.search(**params).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE job_company_website='zenefits.com';
  """

  # Find all records matching query
  all_zenefits_employees = get_all_pdl_records_sql(SQL_QUERY)

  # Create aggregate objects
  skills_agg = {}
  titles_agg = {}
  schools_agg = {}
  other_companies_agg = {}

  # Iterate through records array for aggregation
  for record in all_zenefits_employees:
    # Aggregate skills
    for skill in record['skills']:
      skills_agg.setdefault(skill, 0)
      skills_agg[skill] += 1
    # Aggregate job titles
    if record['job_title']:
      titles_agg.setdefault(record['job_title'], 0)
      titles_agg[record['job_title']] += 1
    # Aggregate schools
    for edu in record['education']:
      if edu['school'] and edu['school']['type'] == "post-secondary institution":
        schools_agg.setdefault(edu['school']['name'], 0)
        schools_agg[edu['school']['name']] += 1
    # Aggregate other companies
    for exp in record['experience']:
      if exp['company'] and exp['company']['name'] != 'zenefits':
        other_companies_agg.setdefault(exp['company']['name'], 0)
        other_companies_agg[exp['company']['name']] += 1

  # Sort aggregate objects by count and print top 10 for each
  print("Top 10 skills for zenefits employees:")
  for skill, count in sorted(
    skills_agg.items(), key = lambda x: x[1], reverse=True
  )[:10]:
    print(count, skill)

  print("Top 10 titles for zenefits employees:")
  for title, count in sorted(
    titles_agg.items(), key = lambda x: x[1], reverse=True
  )[:10]:
    print(count, title)
   
  print("Top 10 universities for zenefits employees:")
  for school, count in sorted(
    schools_agg.items(), key = lambda x: x[1], reverse=True
  )[:10]:
    print(count, school)
    
  print("Top 10 former companies for zenefits employees:")
  for company, count in sorted(
    other_companies_agg.items(), key = lambda x: x[1], reverse=True
  )[:10]:
    print(count, company)
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an Elasticsearch query
  const esQuery = {
  	   "query": {
              "term": {"job_company_website": "zenefits.com"}
          }
  }

  // Store all records retreived in an array
  var allRecords = [];
  // The current scroll_token
  var scrollToken = null;
  var pageSize = 100;
  var batch = 1;

  // Create a parameters JSON object
  var params = {
      searchQuery: esQuery, 
      size: pageSize,
      scroll_token: null,
      dataset: "all"
  }

  // Run batches recursively
  runBatch();

  // Run Person searches in batches
  function runBatch() {

      // Store current scroll_token in parameters object
      params.scroll_token = scrollToken;
      // Pass the current parameters object to the Person Search API
      PDLJSClient.person.search.elastic(params).then((data) => {
          // Add records retrieved to the records array
          Array.prototype.push.apply(allRecords, data.data);
          
          // Store scroll_token from response
          scrollToken = data['scroll_token'];
          
          console.log(`Batch ${batch} success!`);
          batch++;
          
          // Run searches in batches with 6-second intervals  
          if (scrollToken) {
              setTimeout(function() {
                  runBatch(params);
              }, 6000);
          }
      }).catch((error) => {
          console.log("Unable to continue scrolling.");
          console.log("Done!");
          printResults();
      });
  }

  // Aggregate, sort and print data
  function printResults() {

      // Create aggregate objects
      var skillsAgg = {};
      var titlesAgg = {};
      var schoolsAgg = {};
      var otherCompaniesAgg = {};
      
      // Iterate through records array for aggregation
      for (let record in allRecords) {
          // Aggregate skills
          for (let skill in allRecords[record]["skills"]) {
              if (!skillsAgg[allRecords[record]["skills"][skill]]) {
                  skillsAgg[allRecords[record]["skills"][skill]] = 0;
              }
              skillsAgg[allRecords[record]["skills"][skill]]++;
          }
          // Aggregate job titles
          if (allRecords[record]["job_title"]) {
              if (!titlesAgg[allRecords[record]["job_title"]]) {
                  titlesAgg[allRecords[record]["job_title"]] = 0;
              }
              titlesAgg[allRecords[record]["job_title"]]++;
          }
          // Aggregate schools
          for (let edu in allRecords[record]["education"]) {
             if (allRecords[record]["education"][edu]["school"] && 
                 allRecords[record]["education"][edu]["school"]["type"] == "post-secondary institution") {
                     if (!schoolsAgg[allRecords[record]["education"][edu]["school"]["name"]]) {
                         schoolsAgg[allRecords[record]["education"][edu]["school"]["name"]] = 0;
                     }
                     schoolsAgg[allRecords[record]["education"][edu]["school"]["name"]]++;
             }
          }
          // Aggregate other companies
          for (let exp in allRecords[record]["experience"]) {
              if (allRecords[record]["experience"][exp]["company"] && 
                  allRecords[record]["experience"][exp]["company"]["name"] != "zenefits") {
                      if (!otherCompaniesAgg[allRecords[record]["experience"][exp]["company"]["name"]]) {
                          otherCompaniesAgg[allRecords[record]["experience"][exp]["company"]["name"]] = 0;
                      }
                      otherCompaniesAgg[allRecords[record]["experience"][exp]["company"]["name"]]++
              }
          }
      }
      
      console.log("Top 10 skills for zenefits employees:");
      sortAndPrint(skillsAgg);
      
      console.log("Top 10 titles for zenefits employees:");
      sortAndPrint(titlesAgg);
      
      console.log("Top 10 universities for zenefits employees:");
      sortAndPrint(schoolsAgg);
      
      console.log("Top 10 former companies for zenefits employees:");
      sortAndPrint(otherCompaniesAgg);
  }

  // Sort object and print top 10
  function sortAndPrint(object) {
      var sortable = [];
      
      for (let field in object) {
          sortable.push([field, object[field]]);
      }

      sortable.sort(function(a, b) {
          return b[1] - a[1];
          });
      for (let i = 0; i < 10; i++) {
          console.log(sortable[i][0]);    
      }
  }
  ```

  ```javascript JavaScript (SQL) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create an SQL query
  const sqlQuery = `SELECT * FROM person
                      WHERE job_company_website='zenefits.com';`;

  // Store all records retreived in an array
  var allRecords = [];
  // The current scroll_token
  var scrollToken = null;
  var pageSize = 100;
  var batch = 1;

  // Create a parameters JSON object
  var params = {
      searchQuery: sqlQuery, 
      size: pageSize,
      scroll_token: null,
      dataset: "all"
  }

  // Run batches recursively
  runBatch();

  // Run Person searches in batches
  function runBatch() {

      // Store current scroll_token in parameters object
      params.scroll_token = scrollToken;
      // Pass the current parameters object to the Person Search API
      PDLJSClient.person.search.sql(params).then((data) => {
          // Add records retrieved to the records array
          Array.prototype.push.apply(allRecords, data.data);
          
          // Store scroll_token from response
          scrollToken = data['scroll_token'];
          
          console.log(`Batch ${batch} success!`);
          batch++;
          
          // Run searches in batches with 6-second intervals 
          if (scrollToken) {
              setTimeout(function() {
                  runBatch(params);
              }, 6000);
          }
      }).catch((error) => {
          console.log("Unable to continue scrolling.");
          console.log("Done!");
          printResults();
      });
  }

  // Aggregate, sort and print data
  function printResults() {

      // Create aggregate objects
      var skillsAgg = {};
      var titlesAgg = {};
      var schoolsAgg = {};
      var otherCompaniesAgg = {};
      
      // Iterate through records array for aggregation
      for (let record in allRecords) {
          // Aggregate skills
          for (let skill in allRecords[record]["skills"]) {
              if (!skillsAgg[allRecords[record]["skills"][skill]]) {
                  skillsAgg[allRecords[record]["skills"][skill]] = 0;
              }
              skillsAgg[allRecords[record]["skills"][skill]]++;
          }
          // Aggregate job titles
          if (allRecords[record]["job_title"]) {
              if (!titlesAgg[allRecords[record]["job_title"]]) {
                  titlesAgg[allRecords[record]["job_title"]] = 0;
              }
              titlesAgg[allRecords[record]["job_title"]]++;
          }
          // Aggregate schools
          for (let edu in allRecords[record]["education"]) {
             if (allRecords[record]["education"][edu]["school"] && 
                 allRecords[record]["education"][edu]["school"]["type"] == "post-secondary institution") {
                     if (!schoolsAgg[allRecords[record]["education"][edu]["school"]["name"]]) {
                         schoolsAgg[allRecords[record]["education"][edu]["school"]["name"]] = 0;
                     }
                     schoolsAgg[allRecords[record]["education"][edu]["school"]["name"]]++;
             }
          }
          // Aggregate other companies
          for (let exp in allRecords[record]["experience"]) {
              if (allRecords[record]["experience"][exp]["company"] && 
                  allRecords[record]["experience"][exp]["company"]["name"] != "zenefits") {
                      if (!otherCompaniesAgg[allRecords[record]["experience"][exp]["company"]["name"]]) {
                          otherCompaniesAgg[allRecords[record]["experience"][exp]["company"]["name"]] = 0;
                      }
                      otherCompaniesAgg[allRecords[record]["experience"][exp]["company"]["name"]]++
              }
          }
      }
      
      console.log("Top 10 skills for zenefits employees:");
      sortAndPrint(skillsAgg);
      
      console.log("Top 10 titles for zenefits employees:");
      sortAndPrint(titlesAgg);
      
      console.log("Top 10 universities for zenefits employees:");
      sortAndPrint(schoolsAgg);
      
      console.log("Top 10 former companies for zenefits employees:");
      sortAndPrint(otherCompaniesAgg);
  }

  // Sort object and print top 10
  function sortAndPrint(object) {
      var sortable = [];
      
      for (let field in object) {
          sortable.push([field, object[field]]);
      }

      sortable.sort(function(a, b) {
          return b[1] - a[1];
          });
      for (let i = 0; i < 10; i++) {
          console.log(sortable[i][0]);    
      }
  }
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  PAGE_SIZE = 100

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_es(query)

      # Store all records retreived in an array
      all_records = []
      batch = 1
      # The current scroll_token
      scroll_token = {}

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 || !scroll_token.nil?

          # Pass parameters to the Person Search API
          response = Peopledatalabs::Search.person(searchType: 'elastic', query: query, size: PAGE_SIZE, scroll_token: scroll_token, dataset: "all")
  				
          # Check for successful response
          if response['status'] == 200
            # Add records retrieved to the records array
            all_records += response['data']
            # Store the scroll_token for next batch
            scroll_token = response['scroll_token']

            puts "Batch #{batch} success!"
            sleep(6)
            batch += 1
            
          else
            puts "Unable to continue scrolling."
            break
          end
      end
      
      puts "Done!"

      return all_records
  end

  # Create an Elasticsearch query
  ES_QUERY = {
      "query": {
          "term": {"job_company_website": "zenefits.com"}
      }
  }

  # Find all records matching query
  all_zenefits_employees = get_all_pdl_records_es(ES_QUERY)

  # Create aggregate objects
  skills_agg = {}
  titles_agg = {}
  schools_agg = {}
  other_companies_agg = {}

  # Iterate through records array for aggregation
  all_zenefits_employees.each do |record|
      # Aggregate skills
      record['skills'].each do |skill|
          skills_agg[skill] = skills_agg.fetch(skill, 0)
          skills_agg[skill] += 1
      end
      # Aggregate job titles
      if record.key?('job_title')
          titles_agg[record['job_title']] = titles_agg.fetch(record['job_title'], 0)
          titles_agg[record['job_title']] += 1
      end
      # Aggregate schools
      record['education'].each do |edu|
          if edu.key?('school') && !edu['school'].nil? && edu['school']['type'] == "post-secondary institution"
              schools_agg[edu['school']['name']] = schools_agg.fetch(edu['school']['name'], 0)
              schools_agg[edu['school']['name']] += 1
          end
      end
      # Aggregate other companies
      record['experience'].each do |exp|
          if exp.key?('company') && !exp['company'].nil? && exp['company']['name'] != 'zenefits'
              other_companies_agg[exp['company']['name']] = other_companies_agg.fetch(exp['company']['name'], 0)
              other_companies_agg[exp['company']['name']] += 1
          end
      end
  end

  # Sort aggregate objects by count and print top 10 for each
  puts "Top 10 skills for zenefits employees:"
  skills_agg.sort_by(&:last).reverse.first(10).each { |key, value| puts "#{key} #{value}" }

  puts "Top 10 titles for zenefits employees:"
  titles_agg.sort_by(&:last).reverse.first(10).each { |key, value| puts "#{key} #{value}" }

  puts "Top 10 universities for zenefits employees:"
  schools_agg.sort_by(&:last).reverse.first(10).each { |key, value| puts "#{key} #{value}" }
   
  puts "Top 10 former companies for zenefits employees:"
  other_companies_agg.sort_by(&:last).reverse.first(10).each { |key, value| puts "#{key} #{value}" }
  ```

  ```ruby Ruby (SQL) expandable theme={null}
  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  PAGE_SIZE = 100

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_sql(query)

      # Store all records retreived in an array
      all_records = []
      batch = 1
      # The current scroll_token
      scroll_token = {}

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 || !scroll_token.nil?

          # Pass parameters to the Person Search API
          response = Peopledatalabs::Search.person(searchType: 'sql', query: query, size: PAGE_SIZE, scroll_token: scroll_token, dataset: "all")
  				
          # Check for successful response
          if response['status'] == 200
            # Add records retrieved to the records array
            all_records += response['data']
            # Store the scroll_token for next batch
            scroll_token = response['scroll_token']

            puts "Batch #{batch} success!"
            sleep(6)
            batch += 1
            
          else
            puts "Unable to continue scrolling."
            break
          end
      end
      
      puts "Done!"

      return all_records
  end

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE job_company_website='zenefits.com';
  """

  # Find all records matching query
  all_zenefits_employees = get_all_pdl_records_sql(SQL_QUERY)

  # Create aggregate objects
  skills_agg = {}
  titles_agg = {}
  schools_agg = {}
  other_companies_agg = {}

  # Iterate through records array for aggregation
  all_zenefits_employees.each do |record|
      # Aggregate skills
      record['skills'].each do |skill|
          skills_agg[skill] = skills_agg.fetch(skill, 0)
          skills_agg[skill] += 1
      end
      # Aggregate job titles
      if record.key?('job_title')
          titles_agg[record['job_title']] = titles_agg.fetch(record['job_title'], 0)
          titles_agg[record['job_title']] += 1
      end
      # Aggregate schools
      record['education'].each do |edu|
          if edu.key?('school') && !edu['school'].nil? && edu['school']['type'] == "post-secondary institution"
              schools_agg[edu['school']['name']] = schools_agg.fetch(edu['school']['name'], 0)
              schools_agg[edu['school']['name']] += 1
          end
      end
      # Aggregate other companies
      record['experience'].each do |exp|
          if exp.key?('company') && !exp['company'].nil? && exp['company']['name'] != 'zenefits'
              other_companies_agg[exp['company']['name']] = other_companies_agg.fetch(exp['company']['name'], 0)
              other_companies_agg[exp['company']['name']] += 1
          end
      end
  end

  # Sort aggregate objects by count and print top 10 for each
  puts "Top 10 skills for zenefits employees:"
  skills_agg.sort_by(&:last).reverse.first(10).each { |key, value| puts "#{key} #{value}" }

  puts "Top 10 titles for zenefits employees:"
  titles_agg.sort_by(&:last).reverse.first(10).each { |key, value| puts "#{key} #{value}" }

  puts "Top 10 universities for zenefits employees:"
  schools_agg.sort_by(&:last).reverse.first(10).each { |key, value| puts "#{key} #{value}" }
   
  puts "Top 10 former companies for zenefits employees:"
  other_companies_agg.sort_by(&:last).reverse.first(10).each { |key, value| puts "#{key} #{value}" }
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "time"
      "sort"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Create an Elasticsearch query
      elasticSearchQuery := map[string]interface{} {
          "query": map[string]interface{} {
              "bool": map[string]interface{} {
                  "must": []map[string]interface{} {
                      {"term": map[string]interface{}{"job_company_website": "zenefits.com"}},
                  },
              },
          },
      }

      // Find all records matching query
      allZenefitsEmployees := getAllPdlRecordsEs(elasticSearchQuery)
      
      // Create aggregate objects
      skillsAgg := make(map[string]int)
      titlesAgg := make(map[string]int)
      schoolsAgg := make(map[string]int)
      otherCompaniesAgg := make(map[string]int)
      
      // Iterate through records array for aggregation
      for _, record := range allZenefitsEmployees {
          // Aggregate skills
          for _, skill := range record.Skills {
              skillsAgg[skill]++
          }
          // Aggregate job titles
          if record.JobTitle != "" {
              titlesAgg[record.JobTitle]++
          }
          // Aggregate schools
          for _, edu := range record.Education {
              if edu.School.Name != "" && edu.School.Type == "post-secondary institution" {
                  schoolsAgg[edu.School.Name]++
              }
          }
          // Aggregate other companies
          for _, exp := range record.Experience {
              if exp.Company.Name != "zenefits" {
                  otherCompaniesAgg[exp.Company.Name]++
              }
          }
      }
      
      // Sort aggregate objects by count and print top 10 for each
      fmt.Println("Top 10 skills for zenefits employees:")
      for _, skill := range rank(skillsAgg) {
          fmt.Println(skill, skillsAgg[skill])
      }
      
      fmt.Println("Top 10 titles for zenefits employees:")
      for _, title := range rank(titlesAgg) {
          fmt.Println(title, titlesAgg[title])
      }
      
      fmt.Println("Top 10 universities for zenefits employees:")
      for _, school := range rank(schoolsAgg) {
          fmt.Println(school, schoolsAgg[school])
      }
      
      fmt.Println("Top 10 former companies for zenefits employees:")
      for _, company := range rank(otherCompaniesAgg) {
          fmt.Println(company, otherCompaniesAgg[company])
      }
      
  }

  // Run Person searches in batches with 6-second intervals
  func getAllPdlRecordsEs(query interface{}) []pdlmodel.Person {
      // Store all records retreived in an array
      var allRecords []pdlmodel.Person
      batch := 1
      // The current scroll_token
      var scrollToken string
      const pageSize = 100    
          
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create a parameters JSON object
      p := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: pageSize,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              Query: query,
              ScrollToken: scrollToken,
              Dataset: "all",
          },
      }
      
      // Keep retrieving records until unable to continue scrolling
      for batch == 1 || scrollToken != "" {
          // Pass the parameters object to the Person Search API
          response, err := client.Person.Search(context.Background(), p)
          
          // Check for successful response
          if err == nil {
              // Add records retrieved to the records array
              allRecords = append(allRecords, response.Data...)
              // Store scroll_token from response
              p.SearchBaseParams.ScrollToken, scrollToken = response.ScrollToken, response.ScrollToken
              
              fmt.Printf("Batch %d success!\n", batch)
              time.Sleep(6 * time.Second)
              batch++
          } else {
              fmt.Println("Unable to continue scrolling.")
              break
          }
      }
      fmt.Println("Done!")
          
      return allRecords
  }

  // Sort map in reverse order
  func rank(values map[string]int) []string {
      type kv struct {
          Key   string
          Value int
      }
      var ss []kv
      
      for k, v := range values {
          ss = append(ss, kv{k, v})
      }
      sort.Slice(ss, func(i, j int) bool {
          return ss[i].Value > ss[j].Value
      })
      ranked := make([]string, len(values))
      for i, kv := range ss {
          ranked[i] = kv.Key
      }
      
      return ranked
  }
  ```

  ```go Go (SQL) expandable theme={null}
  package main

  import (
      "fmt"
      "time"
      "sort"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Create an SQL query
      sqlQuery := "SELECT * FROM person" +
          " WHERE job_company_website='zenefits.com'"

      // Find all records matching query
      allZenefitsEmployees := getAllPdlRecordsEs(sqlQuery)
      
      // Create aggregate objects
      skillsAgg := make(map[string]int)
      titlesAgg := make(map[string]int)
      schoolsAgg := make(map[string]int)
      otherCompaniesAgg := make(map[string]int)
      
      // Iterate through records array for aggregation
      for _, record := range allZenefitsEmployees {
          // Aggregate skills
          for _, skill := range record.Skills {
              skillsAgg[skill]++
          }
          // Aggregate job titles
          if record.JobTitle != "" {
              titlesAgg[record.JobTitle]++
          }
          // Aggregate schools
          for _, edu := range record.Education {
              if edu.School.Name != "" && edu.School.Type == "post-secondary institution" {
                  schoolsAgg[edu.School.Name]++
              }
          }
          // Aggregate other companies
          for _, exp := range record.Experience {
              if exp.Company.Name != "zenefits" {
                  otherCompaniesAgg[exp.Company.Name]++
              }
          }
      }
      
      // Sort aggregate objects by count and print top 10 for each
      fmt.Println("Top 10 skills for zenefits employees:")
      for _, skill := range rank(skillsAgg) {
          fmt.Println(skill, skillsAgg[skill])
      }
      
      fmt.Println("Top 10 titles for zenefits employees:")
      for _, title := range rank(titlesAgg) {
          fmt.Println(title, titlesAgg[title])
      }
      
      fmt.Println("Top 10 universities for zenefits employees:")
      for _, school := range rank(schoolsAgg) {
          fmt.Println(school, schoolsAgg[school])
      }
      
      fmt.Println("Top 10 former companies for zenefits employees:")
      for _, company := range rank(otherCompaniesAgg) {
          fmt.Println(company, otherCompaniesAgg[company])
      }
      
  }

  // Run Person searches in batches with 6-second intervals
  func getAllPdlRecordsEs(query string) []pdlmodel.Person {
      // Store all records retreived in an array
      var allRecords []pdlmodel.Person
      batch := 1
      // The current scroll_token
      var scrollToken string
      const pageSize = 100    
          
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)

      // Create a parameters JSON object
      p := pdlmodel.SearchParams {
          BaseParams: pdlmodel.BaseParams {
              Size: pageSize,
          },
          SearchBaseParams: pdlmodel.SearchBaseParams {
              SQL: query,
              ScrollToken: scrollToken,
              Dataset: "all",
          },
      }
      
      // Keep retrieving records until unable to continue scrolling
      for batch == 1 || scrollToken != "" {
          // Pass the parameters object to the Person Search API
          response, err := client.Person.Search(context.Background(), p)
          
          // Check for successful response
          if err == nil {
              // Add records retrieved to the records array
              allRecords = append(allRecords, response.Data...)
              // Store scroll_token from response
              p.SearchBaseParams.ScrollToken, scrollToken = response.ScrollToken, response.ScrollToken
              
              fmt.Printf("Batch %d success!\n", batch)
              time.Sleep(6 * time.Second)
              batch++
          } else {
              fmt.Println("Unable to continue scrolling.")
              break
          }
      }
      fmt.Println("Done!")
          
      return allRecords
  }

  // Sort map in reverse order
  func rank(values map[string]int) []string {
      type kv struct {
          Key   string
          Value int
      }
      var ss []kv
      
      for k, v := range values {
          ss = append(ss, kv{k, v})
      }
      sort.Slice(ss, func(i, j int) bool {
          return ss[i].Value > ss[j].Value
      })
      ranked := make([]string, len(values))
      for i, kv := range ss {
          ranked[i] = kv.Key
      }
      
      return ranked
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  from time import sleep
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_es(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'query': json.dumps(query),
          'size': PAGE_SIZE,
          'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = requests.get(
              PDL_URL,
              headers=HEADERS,
              params=params
          ).json()
  				
          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records


  if __name__ == '__main__':
      # Create an Elasticsearch query
      ES_QUERY = {
          "query": {
              "term": {"job_company_website": "zenefits.com"}
          }
      }

      # Find all records matching query
      all_zenefits_employees = get_all_pdl_records_es(ES_QUERY)

      # Create aggregate objects
      skills_agg = {}
      titles_agg = {}
      schools_agg = {}
      other_companies_agg = {}

      # Iterate through records array for aggregation
      for record in all_zenefits_employees:
          # Aggregate skills
          for skill in record['skills']:
              skills_agg.setdefault(skill, 0)
              skills_agg[skill] += 1
          # Aggregate job titles
          if record['job_title']:
              titles_agg.setdefault(record['job_title'], 0)
              titles_agg[record['job_title']] += 1
          # Aggregate schools
          for edu in record['education']:
              if edu['school'] and edu['school']['type'] == "post-secondary institution":
                  schools_agg.setdefault(edu['school']['name'], 0)
                  schools_agg[edu['school']['name']] += 1
          # Aggregate other companies
          for exp in record['experience']:
              if exp['company'] and exp['company']['name'] != 'zenefits':
                  other_companies_agg.setdefault(exp['company']['name'], 0)
                  other_companies_agg[exp['company']['name']] += 1

      # Sort aggregate objects by count and print top 10 for each
      print("Top 10 skills for zenefits employees:")
      for skill, count in sorted(
          skills_agg.items(), key = lambda x: x[1], reverse=True
      )[:10]:
          print(count, skill)

      print("Top 10 titles for zenefits employees:")
      for title, count in sorted(
          titles_agg.items(), key = lambda x: x[1], reverse=True
      )[:10]:
          print(count, title)
   
      print("Top 10 universities for zenefits employees:")
      for school, count in sorted(
          schools_agg.items(), key = lambda x: x[1], reverse=True
      )[:10]:
          print(count, school)
    
      print("Top 10 former companies for zenefits employees:")
      for company, count in sorted(
          other_companies_agg.items(), key = lambda x: x[1], reverse=True
      )[:10]:
          print(count, company)
  ```

  ```python Python3 (SQL) expandable theme={null}
  from time import sleep
  import requests, json

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Set the Person Search API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set headers
  HEADERS = {
    'Content-Type': "application/json",
    'X-api-key': API_KEY
  }

  # Run Person searches in batches with 6-second intervals
  def get_all_pdl_records_sql(query):

      PAGE_SIZE = 100

      # Store all records retreived in an array
      all_records = []
      batch = 1

      # Create a parameters JSON object
      params = {
          'sql': query,
          'size': PAGE_SIZE,
        	'dataset': "all"
      }

      # Keep retrieving records until unable to continue scrolling
      while batch == 1 or params['scroll_token']:

          # Pass the parameters object to the Person Search API
          response = requests.get(
              PDL_URL,
              headers=HEADERS,
              params=params
          ).json()

          # Check for successful response
          if response['status'] == 200:
            # Add records retrieved to the records array
            all_records.extend(response['data'])
            # Store the scroll_token for next batch
            params['scroll_token'] = response['scroll_token']

            print(f"Batch {batch} success!")
            sleep(6)
            batch += 1
            
          else:
            print("Unable to continue scrolling.")
            break
      
      print("Done!")

      return all_records

  # Create an SQL query
  SQL_QUERY = \
  """
    SELECT * FROM person
    WHERE job_company_website='zenefits.com';
  """

  # Find all records matching query
  all_zenefits_employees = get_all_pdl_records_sql(SQL_QUERY)

  # Create aggregate objects
  skills_agg = {}
  titles_agg = {}
  schools_agg = {}
  other_companies_agg = {}

  # Iterate through records array for aggregation
  for record in all_zenefits_employees:
    # Aggregate skills
    for skill in record['skills']:
      skills_agg.setdefault(skill, 0)
      skills_agg[skill] += 1
    # Aggregate job titles
    if record['job_title']:
      titles_agg.setdefault(record['job_title'], 0)
      titles_agg[record['job_title']] += 1
    # Aggregate schools
    for edu in record['education']:
      if edu['school'] and edu['school']['type'] == "post-secondary institution":
        schools_agg.setdefault(edu['school']['name'], 0)
        schools_agg[edu['school']['name']] += 1
    # Aggregate other companies
    for exp in record['experience']:
      if exp['company'] and exp['company']['name'] != 'zenefits':
        other_companies_agg.setdefault(exp['company']['name'], 0)
        other_companies_agg[exp['company']['name']] += 1

  # Sort aggregate objects by count and print top 10 for each
  print("Top 10 skills for zenefits employees:")
  for skill, count in sorted(
    skills_agg.items(), key = lambda x: x[1], reverse=True
  )[:10]:
    print(count, skill)

  print("Top 10 titles for zenefits employees:")
  for title, count in sorted(
    titles_agg.items(), key = lambda x: x[1], reverse=True
  )[:10]:
    print(count, title)
   
  print("Top 10 universities for zenefits employees:")
  for school, count in sorted(
    schools_agg.items(), key = lambda x: x[1], reverse=True
  )[:10]:
    print(count, school)
    
  print("Top 10 former companies for zenefits employees:")
  for company, count in sorted(
    other_companies_agg.items(), key = lambda x: x[1], reverse=True
  )[:10]:
    print(count, company)
  ```
</CodeGroup>

## Advanced Examples

### Company Enrichment and Person Search

*"I want to find X number of people at each company in my list."*

<CodeGroup>
  ```python Python SDK (Elasticsearch) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create a list a companies to search
  COMPANY_WEBSITES = [
      "facebook.com",
      "amazon.com",
      "apple.com",
      "netflix.com",
      "google.com"
  ]

  # Set the maximum people to search at each company
  MAX_NUM_PEOPLE = 100

  # Enrich each company then find people at that company
  for company_website in COMPANY_WEBSITES:

      # Create a parameters JSON object for the Company Enrichment API
      query_string = { "website": company_website }

      # Pass the parameters object to the Company Enrichment API
      response = CLIENT.company.enrichment(**query_string).json()

      # Check for successful response
      if response['status'] == 200:
          # Store enriched company
          enriched_company = response
      else:
          enriched_company = {}
          print(f"Company Enrichment Error for [{company_website}]: {response.text}")

      # Store employees at each company
      company_employee_matches = {}

      # Check for an enriched company
      if enriched_company:
          # Create an Elasticsearch query
          es_query = {
          "query": {
              "bool": {
                  "must": [
                          {"term": {"job_company_id": enriched_company["id"]}},
                      ]
                  }
              }
          }

          # Create a parameters JSON object for the Person Search API
          params = {
              'query': es_query,
              'size': MAX_NUM_PEOPLE
          }

          # Pass the parameters object to the Person Search API
          response = CLIENT.person.search(**params).json()

          # Check for successful response
          if response['status'] == 200:
              # Get employees from response
              company_employee_matches = response['data']
          else:
              company_employee_matches = {}
              print(f"Person Search Error for [{company_website}]: {response.text}")

      print(f"Found {len(company_employee_matches)} employee profiles at {company_website}.")
  ```

  ```python Python SDK (SQL) expandable theme={null}
  import json

  # See https://github.com/peopledatalabs/peopledatalabs-python
  from peopledatalabs import PDLPY

  # Create a client, specifying your API key
  CLIENT = PDLPY(
      api_key="YOUR API KEY",
  )

  # Create a list a companies to search
  COMPANY_WEBSITES = [
      "facebook.com",
      "amazon.com",
      "apple.com",
      "netflix.com",
      "google.com"
  ]

  # Set the maximum people to search at each company
  MAX_NUM_PEOPLE = 100

  # Enrich each company then find people at that company
  for company_website in COMPANY_WEBSITES:

      # Create a parameters JSON object for the Company Enrichment API
      query_string = { "website": company_website }

      # Pass the parameters object to the Company Enrichment API
      response = CLIENT.company.enrichment(**query_string).json()

      # Check for successful response
      if response['status'] == 200:
          # Store enriched company
          enriched_company = response
      else:
          enriched_company = {}
          print(f"Company Enrichment Error for [{company_website}]: {response.text}")

      # Store employees at each company
      company_employee_matches = {}

      # Check for an enriched company
      if enriched_company:
          sql_query = f"""
          SELECT * FROM person
          WHERE job_company_id = '{enriched_company['id']}'
          """

          # Create a parameters JSON object for the Person Search API
          params = {
              'sql': sql_query,
              'size': MAX_NUM_PEOPLE
          }

          # Pass the parameters object to the Person Search API
          response = CLIENT.person.search(**params).json()

          # Check for successful response
          if response['status'] == 200:
              # Get employees from response
              company_employee_matches = response['data']
          else:
              company_employee_matches = {}
              print(f"Person Search Error for [{company_website}]: {response.text}")

      print(f"Found {len(company_employee_matches)} employee profiles at {company_website}.")
  ```

  ```javascript JavaScript (Elasticsearch) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create a list a companies to search
  const companyWebsites = [
      "facebook.com",
      "amazon.com",
      "apple.com",
      "netflix.com",
      "google.com"
  ];

  // Set the maximum people to search at each company
  const maxMumPeople = 100;

  // Enrich each company then find people at that company
  for (let companyWebsite = 0; companyWebsite < companyWebsites.length; companyWebsite++) {

      // Create a parameters JSON object for the Company Enrichment API
      let queryString = { "website": companyWebsites[companyWebsite] };
      
      let enrichedCompany = {};
      // Store employees at each company
      let companyEmployeeMatches = {};
      
      // Pass the parameters object to the Company Enrichment API
      PDLJSClient.company.enrichment(queryString).then((enrichedCompany) => {

          // Create an Elasticsearch query    
          let esQuery = {
              query: {
                  bool: {
                      must:[
                          {term: {job_company_id: enrichedCompany.id}}, 
                      ]
                  }
              }
          }
          
          // Create a parameters JSON object for the Person Search API
          let params = {
              searchQuery: esQuery, 
              size: maxMumPeople
          }
          
          // Pass the parameters object to the Person Search API
          PDLJSClient.person.search.elastic(params).then((data) => {    
              // Get employees from response
              companyEmployeeMatches = data.data;
              console.log(`Found ${companyEmployeeMatches.length}` +  
                          ` employee profiles at ${companyWebsites[companyWebsite]}.`);
            }).catch((error) => {
                  console.log(`Person Seach Error for ${companyWebsites[companyWebsite]}` + 
                              `: ${error}`);
          }); 
          
      }).catch((error) => {
          console.log(`Company Enrichment Error for ${companyWebsites[companyWebsite]}` + 
                      `: ${error}`);
      }); 
  }
  ```

  ```javascript JavaScript (SQL) expandable theme={null}
  // See https://github.com/peopledatalabs/peopledatalabs-js
  import PDLJS from 'peopledatalabs';

  // Create a client, specifying your API key
  const PDLJSClient = new PDLJS({ apiKey: "YOUR API KEY" });

  // Create a list a companies to search
  const companyWebsites = [
      "facebook.com",
      "amazon.com",
      "apple.com",
      "netflix.com",
      "google.com"
  ];

  // Set the maximum people to search at each company
  const maxMumPeople = 100;

  // Enrich each company then find people at that company
  for (let companyWebsite = 0; companyWebsite < companyWebsites.length; companyWebsite++) {

      // Create a parameters JSON object for the Company Enrichment API
      let queryString = { "website": companyWebsites[companyWebsite] };
      
      let enrichedCompany = {};
      // Store employees at each company
      let companyEmployeeMatches = {};
      
      // Pass the parameters object to the Company Enrichment API
      PDLJSClient.company.enrichment(queryString).then((enrichedCompany) => {

          // Create an SQL query
          let sqlQuery = `SELECT * FROM person
              WHERE job_company_id = '${enrichedCompany.id}';`;
          
          // Create a parameters JSON object for the Person Search API
          let params = {
              searchQuery: sqlQuery, 
              size: maxMumPeople
          }
          
          // Pass the parameters object to the Person Search API
          PDLJSClient.person.search.sql(params).then((data) => {   
              // Get employees from response
              companyEmployeeMatches = data.data;
              console.log(`Found ${companyEmployeeMatches.length}` +  
                          ` employee profiles at ${companyWebsites[companyWebsite]}.`);
            }).catch((error) => {
                  console.log(`Person Seach Error for ${companyWebsites[companyWebsite]}` + 
                              `: ${error}`);
          }); 
          
      }).catch((error) => {
          console.log(`Company Enrichment Error for ${companyWebsites[companyWebsite]}` + 
                      `: ${error}`);
      }); 
  }
  ```

  ```ruby Ruby (Elasticsearch) expandable theme={null}
  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create a list a companies to search
  COMPANY_WEBSITES = [
      "facebook.com",
      "amazon.com",
      "apple.com",
      "netflix.com",
      "google.com"
  ]

  # Set the maximum people to search at each company
  MAX_NUM_PEOPLE = 100

  # Enrich each company then find people at that company
  COMPANY_WEBSITES.each do |company_website|

      # Create a parameters JSON object for the Company Enrichment API
      query_string = { "website": company_website }

      # Pass the parameters object to the Company Enrichment API
      response = Peopledatalabs::Enrichment.company(params: query_string)

      # Check for successful response
      if response['status'] == 200
          # Store enriched company
          enriched_company = response
      else
          enriched_company = {}
          puts "Company Enrichment Error for [#{company_website}]: #{response}"
      end

      # Store employees at each company
      company_employee_matches = {}

      # Check for an enriched company
      if !enriched_company.nil?
          # Create an Elasticsearch query
          es_query = {
          "query": {
              "bool": {
                  "must": [
                          {"term": {"job_company_id": enriched_company["id"]}},
                      ]
                  }
              }
          }

          # Pass parameters to the Person Search API
          response = Peopledatalabs::Search.person(searchType: 'elastic', query: es_query, size: MAX_NUM_PEOPLE)

          # Check for successful response
          if response['status'] == 200
              # Get employees from response
              company_employee_matches = response['data']
          else
              company_employee_matches = {}
              puts "Person Search Error for [#{company_website}]: #{response}"
          end
      end

      puts "Found #{company_employee_matches.length()} employee profiles at #{company_website}."
  end
  ```

  ```ruby Ruby (SQL) expandable theme={null}
  # See https://github.com/peopledatalabs/peopledatalabs-ruby
  require 'peopledatalabs'

  # Set your API key
  Peopledatalabs.api_key = 'YOUR API KEY'

  # Create a list a companies to search
  COMPANY_WEBSITES = [
      "facebook.com",
      "amazon.com",
      "apple.com",
      "netflix.com",
      "google.com"
  ]

  # Set the maximum people to search at each company
  MAX_NUM_PEOPLE = 100

  # Enrich each company then find people at that company
  COMPANY_WEBSITES.each do |company_website|

      # Create a parameters JSON object for the Company Enrichment API
      query_string = { "website": company_website }

      # Pass the parameters object to the Company Enrichment API
      response = Peopledatalabs::Enrichment.company(params: query_string)

      # Check for successful response
      if response['status'] == 200
          # Store enriched company
          enriched_company = response
      else
          enriched_company = {}
          puts "Company Enrichment Error for [#{company_website}]: #{response}"
      end

      # Store employees at each company
      company_employee_matches = {}

      # Check for an enriched company
      if !enriched_company.nil?
          # Create an SQL query
          sql_query = """
          SELECT * FROM person
          WHERE job_company_id = '#{enriched_company['id']}'
          """

          # Pass parameters to the Person Search API
          response = Peopledatalabs::Search.person(searchType: 'sql', query: sql_query, size: MAX_NUM_PEOPLE)

          # Check for successful response
          if response['status'] == 200
              # Get employees from response
              company_employee_matches = response['data']
          else
              company_employee_matches = {}
              puts "Person Search Error for [#{company_website}]: #{response}"
          end
      end

      puts "Found #{company_employee_matches.length()} employee profiles at #{company_website}."
  end
  ```

  ```go Go (Elasticsearch) expandable theme={null}
  package main

  import (
      "fmt"
      "reflect"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)
      
      // Create a list a companies to search
      companyWebsites := 
          []string{"facebook.com","amazon.com","apple.com","netflix.com","google.com"}

      // Set the maximum people to search at each company
      const maxNumPeople = 100
      
      // Enrich each company then find people at that company
      for _, companyWebsite := range companyWebsites {
          
          var enrichedCompany pdlmodel.EnrichCompanyResponse
          
          // Create a parameters JSON object for the Company Enrichment API
          queryString := pdlmodel.CompanyParams{Website: companyWebsite}
          
          paramsCompany := pdlmodel.EnrichCompanyParams {
              CompanyParams: queryString,
          }
      
          // Pass the parameters object to the Company Enrichment API
          responseCompany, errCompany := client.Company.Enrich(context.Background(), paramsCompany)

          // Check for successful response
          if errCompany == nil {
              // Store enriched company
              enrichedCompany = responseCompany
          } else {
              fmt.Printf("Company Enrichment Error for [%s]: %s\n", companyWebsite, errCompany)
          }
          
          // Store employees at each company
          var companyEmployeeMatches []pdlmodel.Person
          
          // Check for an enriched company
          if !reflect.DeepEqual(enrichedCompany, pdlmodel.EnrichCompanyResponse{}) {
              // Create an Elasticsearch query
              elasticSearchQuery := map[string]interface{} {
                  "query": map[string]interface{} {
                      "bool": map[string]interface{} {
                          "must": []map[string]interface{} {
                              {"term": map[string]interface{}{"job_company_id": enrichedCompany.Id}},
                          },
                      },
                  },
              }

              // Create a parameters JSON object for the Person Search API
              paramsPerson := pdlmodel.SearchParams {
                  BaseParams: pdlmodel.BaseParams {
                      Size: maxNumPeople,
                  },
                  SearchBaseParams: pdlmodel.SearchBaseParams {
                      Query: elasticSearchQuery,
                  },
              }
              
              // Pass the parameters object to the Person Search API
              responsePerson, errPerson := client.Person.Search(context.Background(), paramsPerson)
              
              // Check for successful response
              if errPerson == nil {
                  // Get employees from response
                  companyEmployeeMatches = responsePerson.Data
              } else {
                  fmt.Printf("Person Search Error for [%s]: %s\n", companyWebsite, errPerson)
              }
          }
          fmt.Printf("Found %d employee profiles at %s.\n", len(companyEmployeeMatches), companyWebsite)
      }
  }
  ```

  ```go Go (SQL) expandable theme={null}
  package main

  import (
      "fmt"
      "reflect"
      "context"
  )

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      pdlmodel "github.com/peopledatalabs/peopledatalabs-go/model"
  )

  func main() {
      // Set your API key
      apiKey := "YOUR API KEY"
      // Set API key as environmental variable
      // apiKey := os.Getenv("API_KEY")

      // Create a client, specifying your API key
      client := pdl.New(apiKey)
      
      // Create a list a companies to search
      companyWebsites := 
          []string{"facebook.com","amazon.com","apple.com","netflix.com","google.com"}

      // Set the maximum people to search at each company
      const maxNumPeople = 100
      
      // Enrich each company then find people at that company
      for _, companyWebsite := range companyWebsites {
          
          var enrichedCompany pdlmodel.EnrichCompanyResponse
          
          // Create a parameters JSON object for the Company Enrichment API
          queryString := pdlmodel.CompanyParams{Website: companyWebsite}
          
          paramsCompany := pdlmodel.EnrichCompanyParams {
              CompanyParams: queryString,
          }
      
          // Pass the parameters object to the Company Enrichment API
          responseCompany, errCompany := client.Company.Enrich(context.Background(), paramsCompany)

          // Check for successful response
          if errCompany == nil {
              // Store enriched company
              enrichedCompany = responseCompany
          } else {
              fmt.Printf("Company Enrichment Error for [%s]: %s\n", companyWebsite, errCompany)
          }
          
          // Store employees at each company
          var companyEmployeeMatches []pdlmodel.Person
          
          // Check for an enriched company
          if !reflect.DeepEqual(enrichedCompany, pdlmodel.EnrichCompanyResponse{}) {
              // Create an SQL query
              sqlQuery := "SELECT * FROM person" +
                  " WHERE job_company_id = '" + enrichedCompany.Id + "'"
   
              // Create a parameters JSON object for the Person Search API
              paramsPerson := pdlmodel.SearchParams {
                  BaseParams: pdlmodel.BaseParams {
                      Size: maxNumPeople,
                  },
                  SearchBaseParams: pdlmodel.SearchBaseParams {
                      SQL: sqlQuery,
                  },
              }
              
              // Pass the parameters object to the Person Search API
              responsePerson, errPerson := client.Person.Search(context.Background(), paramsPerson)
              
              // Check for successful response
              if errPerson == nil {
                  // Get employees from response
                  companyEmployeeMatches = responsePerson.Data
              } else {
                  fmt.Printf("Person Search Error for [%s]: %s\n", companyWebsite, errPerson)
              }
          }
          fmt.Printf("Found %d employee profiles at %s.\n", len(companyEmployeeMatches), companyWebsite)
      }
  }
  ```

  ```python Python3 (Elasticsearch) expandable theme={null}
  import json
  import requests

  # Set the Company Enrichment API URL
  PDL_COMPANY_ENRICH_URL = "https://api.peopledatalabs.com/v5/company/enrich"
  # Set the Person Search API URL
  PDL_PERSON_SEARCH_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Create a list a companies to search
  COMPANY_WEBSITES = [
      "facebook.com",
      "amazon.com",
      "apple.com",
      "netflix.com",
      "google.com"
  ]

  # Set the maximum people to search at each company
  MAX_NUM_PEOPLE = 100

  # Enrich each company then find people at that company
  for company_website in COMPANY_WEBSITES:

      # Create a parameters JSON object for the Company Enrichment API
      query_string = { "website": company_website }

      # Set headers
      headers = {
          'accept': "application/json",
          'content-type': "application/json",
          'x-api-key': API_KEY
      }

      # Pass the parameters object to the Company Enrichment API
      response = requests.request("GET", PDL_COMPANY_ENRICH_URL, headers=headers, params=query_string)

      # Check for successful response
      if response.status_code == 200:
          # Store enriched company
          enriched_company = response.json()
      else:
          enriched_company = {}
          print(f"Company Enrichment Error for [{company_website}]: {response.text}")

      # Store employees at each company
      company_employee_matches = {}

      # Check for an enriched company
      if enriched_company:
          # Set headers
          headers = {
              'Content-Type': "application/json",
              'X-api-key': API_KEY
          }

          # Create an Elasticsearch query
          es_query = {
          "query": {
              "bool": {
                  "must": [
                          {"term": {"job_company_id": enriched_company["id"]}},
                      ]
                  }
              }
          }

          # Create a parameters JSON object for the Person Search API
          params = {
              'query': json.dumps(es_query),
              'size': MAX_NUM_PEOPLE
          }

          # Pass the parameters object to the Person Search API
          response = requests.get( PDL_PERSON_SEARCH_URL, headers=headers, params=params)

          # Check for successful response
          if response.status_code == 200:
              # Get employees from response
              company_employee_matches = response.json()['data']
          else:
              company_employee_matches = {}
              print(f"Person Search Error for [{company_website}]: {response.text}")

      print(f"Found {len(company_employee_matches)} employee profiles at {company_website}.")
  ```

  ```python Python3 (SQL) expandable theme={null}
  import json
  import requests

  # Set the Company Enrichment API URL
  PDL_COMPANY_ENRICH_URL = "https://api.peopledatalabs.com/v5/company/enrich"
  # Set the Person Search API URL
  PDL_PERSON_SEARCH_URL = "https://api.peopledatalabs.com/v5/person/search"

  # Set your API key
  API_KEY = "YOUR API KEY"

  # Create a list a companies to search
  COMPANY_WEBSITES = [
      "facebook.com",
      "amazon.com",
      "apple.com",
      "netflix.com",
      "google.com"
  ]

  # Set the maximum people to search at each company
  MAX_NUM_PEOPLE = 100

  # Enrich each company then find people at that company
  for company_website in COMPANY_WEBSITES:

      # Create a parameters JSON object for the Company Enrichment API
      query_string = { "website": company_website }

      # Set headers
      headers = {
          'accept': "application/json",
          'content-type': "application/json",
          'x-api-key': API_KEY
      }

      # Pass the parameters object to the Company Enrichment API
      response = requests.request("GET", PDL_COMPANY_ENRICH_URL, headers=headers, params=query_string)

      # Check for successful response
      if response.status_code == 200:
          # Store enriched company
          enriched_company = response.json()
      else:
          enriched_company = {}
          print(f"Company Enrichment Error for [{company_website}]: {response.text}")

      # Store employees at each company
      company_employee_matches = {}

      # Check for an enriched company
      if enriched_company:
          # Set headers
          headers = {
              'Content-Type': "application/json",
              'X-api-key': API_KEY
          }

          # Create an SQL query
          sql_query = f"""
          SELECT * FROM person
          WHERE job_company_id = '{enriched_company['id']}'
          """

          # Create a parameters JSON object for the Person Search API
          params = {
              'sql': sql_query,
              'size': MAX_NUM_PEOPLE
          }

          # Pass the parameters object to the Person Search API
          response = requests.get( PDL_PERSON_SEARCH_URL, headers=headers, params=params)

          # Check for successful response
          if response.status_code == 200:
              # Get employees from response
              company_employee_matches = response.json()['data']
          else:
              company_employee_matches = {}
              print(f"Person Search Error for [{company_website}]: {response.text}")

      print(f"Found {len(company_employee_matches)} employee profiles at {company_website}.")
  ```
</CodeGroup>


## Related topics

- [Person Search API](/docs/person-search-api.md)
- [Quickstart - Person Search API](/docs/quickstart-person-search-api.md)
- [Reference - Person Search API](/docs/reference-person-search-api.md)
- [Output Response - Person Search API](/docs/output-response-person-search-api.md)
- [Input Parameters - Person Search API](/docs/input-parameters-person-search-api.md)