> ## 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 - Sandbox APIs

We've provided code samples in Python, Ruby, Go and JavaScript.

<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>

## Sandbox Person Enrichment API

To use the Sandbox Person Enrichment API in URL, set `https://sandbox.api.peopledatalabs.com/v5/person/enrich` as the URL and then use the Person Enrichment API as usual.

To use the Sandbox Person Enrichment API with our SDKs, see [SDK usage](/docs/sandbox-apis-reference#sdk-usage).

After implementing one of the two mechanisms above, you can make use of any of the [examples for the Person Enrichment API](/docs/examples-person-enrichment-api). **However, since the Sandbox APIs only use the[Sandbox Dataset](/docs/sandbox-apis-reference#sandbox-dataset), you can only enrich profiles from that dataset**. For example, here is how to perform enrichment on an email address from the [Sandbox Dataset](/docs/sandbox-apis-reference#sandbox-dataset) following the [Email example](/docs/examples-person-enrichment-api#email):

### Basic Usage

<CodeGroup>
  ```python Python3 SDK 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",
      # Use Sandbox API
      sandbox=True,
  )

  # Create a parameters JSON object
  PARAMS = {
      "email": ["irussell@example.org"],
      "min_likelihood": 6
  }

  # Pass the parameters object to the Person Enrichment API
  json_response = CLIENT.person.enrichment(**PARAMS).json()

  # Check for successful response
  if json_response["status"] == 200:
    record = json_response['data']

    # Print selected fields
    print(
      record['work_email'],
      record['full_name'],
      record['job_title'],
      record['job_company_name']
    )

    print(f"Successfully enriched profile with PDL data.")

    # Save enrichment data to JSON file
    with open("my_pdl_enrichment.jsonl", "w") as out:
      out.write(json.dumps(record) + "\n")
  else:
    print("Enrichment unsuccessful. See error and try again.")
    print("error:", json_response)
  ```

  ```javascript JavaScript 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 a parameters JSON object
  const params = {
    email: "irussell@example.org",
    min_likelihood: 6,
    // Use Sandbox API
    sandbox: true
  }

  // Pass the parameters object to the Person Enrichment API
  PDLJSClient.person.enrichment(params).then((data) => {
      var record = data.data
      
      // Print selected fields
      console.log(
          record["work_email"],
          record["full_name"],
          record["job_title"],
          record["job_company_name"],
          )
          
      console.log("Successfully enriched profile with PDL data.")
      
      // Save enrichment data to JSON file
      fs.writeFile("my_pdl_enrichment.jsonl", Buffer.from(JSON.stringify(record)), (err) => {
          if (err) throw err;
      });
  }).catch((error) => {
      console.log("Enrichment unsuccessful. See error and try again.")
      console.log(error);
  });
  ```

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

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

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

  # Use Sandbox API
  Peopledatalabs.sandbox = true

  # Create a parameters JSON object
  PARAMS = {
      "email": ["irussell@example.org"],
      "min_likelihood": 6
  }

  # Pass the parameters object to the Person Enrichment API
  json_response = Peopledatalabs::Enrichment.person(params: PARAMS)

  # Check for successful response
  if json_response['status'] == 200
      record = json_response['data']
      
      # Print selected fields
      puts \
          "#{record['work_email']}\
          #{record['full_name']}\
          #{record['job_title']}\
          #{record['job_company_name']}"
      
      puts "Successfully enriched profile with PDL data."
      
      # Save enrichment data to JSON file
      File.open("my_pdl_enrichment.jsonl", "w") do |out|
          out.write(JSON.dump(record) + "\n")
      end
  else
      puts "Enrichment unsuccessful. See error and try again."
      puts "error: #{json_response}"
  end
  ```

  ```go Go 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"
      "github.com/peopledatalabs/peopledatalabs-go/api"
      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 and sandbox usage
      client := pdl.New(apiKey,
                        api.ClientOptions(func(c *api.Client) {
                                      c.Sandbox = true
                        }))
      
      // Create a parameters JSON object
      params := pdlmodel.EnrichPersonParams {
          PersonParams: pdlmodel.PersonParams {
              Email: []string{"irussell@example.org"},
          },
           AdditionalParams: pdlmodel.AdditionalParams {
              MinLikelihood: 6,
          },
      }
      
      // Pass the parameters object to the Person Enrichment API
      response, err := client.Person.Enrich(context.Background(), params)
      
      // Check for successful response
      if err == nil {
          // Convert the API response to JSON
          jsonResponse, jsonErr := json.Marshal(response.Data)
          if jsonErr == nil {
              var record map[string]interface{}
              json.Unmarshal(jsonResponse, &record)
              // Print selected fields
              fmt.Println(
                         record["work_email"], 
                         record["full_name"], 
                         record["job_title"], 
                         record["job_company_name"])
          
              fmt.Println("Successfully enriched profile with PDL data.")
          
              // Save enrichment data to JSON file
              out, outErr := os.Create("my_pdl_enrichment.jsonl")
              defer out.Close()
              if outErr == nil {
                  out.WriteString(string(jsonResponse) + "\n")
              }
              out.Sync()
          }
     	} else {
          fmt.Println("Enrichment unsuccessful. See error and try again.")
          fmt.Println("error:", err)
      }
  }
  ```

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

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

  # Set the Person Enrichment API URL
  PDL_URL = "https://sandbox.api.peopledatalabs.com/v5/person/enrich" # Sandbox Person Enrichment API
  # PDL_URL = "https://api.peopledatalabs.com/v5/person/enrich" # Production Person Enrichment API

  # Create a parameters JSON object
  PARAMS = {
      "api_key": API_KEY,
      "email": ["irussell@example.org"],
      "min_likelihood": 6
  }

  # Pass the parameters object to the Sandbox Person Enrichment API
  json_response = requests.get(PDL_URL,  params=PARAMS).json()

  # Check for successful response
  if json_response["status"] == 200:
    record = json_response['data']

    # Print selected fields
    print(
      record['work_email'],
      record['full_name'],
      record['job_title'],
      record['job_company_name']
    )

    print(f"Successfully enriched profile with PDL data.")

    # Save enrichment data to JSON file
    with open("my_pdl_enrichment.jsonl", "w") as out:
      out.write(json.dumps(record) + "\n")
  else:
    print("Enrichment unsuccessful. See error and try again.")
    print("error:", json_response)
  ```
</CodeGroup>

See [Examples - Person Enrichment API](/docs/examples-person-enrichment-api) for additonal examples.

## Sandbox Person Search API

To use the Sandbox Person Search API in URL, set `https://sandbox.api.peopledatalabs.com/v5/person/search` as the URL and then use the Person Search API as usual.

To use the Sandbox Person Search API with our SDKs, see [SDK usage](/docs/sandbox-apis-reference#sdk-usage).

After implementing one of the two mechanisms above, you can make use of any of the [examples for the Person Search API](/docs/examples-person-search-api). **However, since the Sandbox APIs only use the[Sandbox Dataset](/docs/sandbox-apis-reference#sandbox-dataset), you can only search for profiles from that dataset**. For example, here is how to perform a simple query following the [Basic Usage example](/docs/examples-person-search-api#basic-usage):

### Basic Usage

<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",
      # Use Sandbox API
      sandbox=True,
  )

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

  # 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)
  ```

  ```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"}}, 
          {exists: {field: "emails"}}
        ]
      }
    }
  }

  // Create a parameters JSON object
  const params = {
    searchQuery: esQuery, 
    size: 10,
    pretty: true,
    // Use Sandbox API
    sandbox: 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);
  });
  ```

  ```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'

  # Use Sandbox API
  Peopledatalabs.sandbox = true

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

  # 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
  ```

  ```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"
      "github.com/peopledatalabs/peopledatalabs-go/api"
      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 and sandbox usage
      client := pdl.New(apiKey,
                        api.ClientOptions(func(c *api.Client) {
                                      c.Sandbox = true
                        }))

      // 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"}},
                      {"exists": map[string]interface{}{"field": "emails"}},
                  },
              },
          },
      }

      // 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)
      } 
  }
  ```

  ```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://sandbox.api.peopledatalabs.com/v5/person/search" # Sandbox Person Search API
  # PDL_URL = "https://api.peopledatalabs.com/v5/person/search" # Production Person Search API

  # 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"}},
              {"exists": {"field": "emails"}}
        ]
      }
    }
  }

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

  # Pass the parameters object to the Sandbox 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>

See [Examples - Person Search API](/docs/examples-person-search-api) for additional examples.

## Sandbox Person Identify API

To use the Sandbox Person Identify API in URL, set `https://sandbox.api.peopledatalabs.com/v5/person/identify` as the URL and then use the Person Identify API as usual.

To use the Sandbox Person Identify API with our SDKs, see [SDK usage](/docs/sandbox-apis-reference#sdk-usage).

After implementing one of the two mechanisms above, you can make use of any of the [examples for the Person Identify API](/docs/identify-api-examples). **However, since the Sandbox APIs only use the[Sandbox Dataset](/docs/sandbox-apis-reference#sandbox-dataset), you can only match profiles from that dataset**. For example, here is how to perform a query following the [Basic Usage example](/docs/identify-api-examples#basic-usage):

### Basic Usage

<CodeGroup>
  ```python Python3 SDK 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",
      # Use Sandbox API
      sandbox=True,
  )

  # Create a parameters JSON object
  PARAMS = {
   "company": "walmart",
   "pretty": True
  }

  # Pass the parameters object to the Person Identify API
  response_data = CLIENT.person.identify(**PARAMS).json()

  # Create a list of matches
  identities = response_data['matches']

  # Print the matches in JSON format
  print(identities)
  print(f"Found {len(identities)} identities!")
  ```

  ```javascript JavaScript 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 parameters JSON object
  const params = {
    company: "walmart",
    pretty: true,
    // Use Sandbox API
    sandbox: true
  }

  // Pass the parameters object to the Person Identify API
  PDLJSClient.person.identify(params).then((data) => {
    // Create a list of matches
    var identities = data["matches"]
    
    // Print the matches in JSON format
    console.log(identities);
    console.log(`Found ${identities.length} identities!`)
  }).catch((error) => {
    console.log(error);
  });
  ```

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

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

  # Use Sandbox API
  Peopledatalabs.sandbox = true

  # Create a parameters JSON object
  PARAMS = {
   "company": "walmart",
   "pretty": true
  }

  # Pass the parameters object to the Person Identify API
  response = Peopledatalabs::Identify.person(params: PARAMS)

  # Create a list of matches
  identities = response['matches']

  # Print the matches in JSON format
  puts identities
  puts "Found #{identities.length()} identities!"
  ```

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

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

  // See https://github.com/peopledatalabs/peopledatalabs-go
  import (
      pdl "github.com/peopledatalabs/peopledatalabs-go"
      "github.com/peopledatalabs/peopledatalabs-go/api"
      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 and sandbox usage
      client := pdl.New(apiKey,
                        api.ClientOptions(func(c *api.Client) {
                                      c.Sandbox = true
                        }))
      
      // Create a parameters JSON object
      params := pdlmodel.IdentifyPersonParams {
          BaseParams: pdlmodel.BaseParams {
              Pretty: true,
          },
          PersonParams: pdlmodel.PersonParams {
               Company: []string{"walmart"},
          },
      }
      
      // Pass the parameters object to the Person Identify API
      response, err := client.Person.Identify(context.Background(), params)
      // Check for successful response
      if err == nil {
          // Create a list of matches
          identities := response.Matches
          // Convert the matches to JSON
          jsonResponse, jsonErr := json.Marshal(identities)
          // Print the matches
          if (jsonErr == nil) {
              fmt.Println(string(jsonResponse))
          }
          
          fmt.Printf("Found %d identities!\n", len(identities))
      } else {
          fmt.Println(err)
      }
  }
  ```

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

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

  # Set the Person Identify API URL
  PDL_URL = "https://sandbox.api.peopledatalabs.com/v5/person/identify" # Sandbox Identify API 
  # PDL_URL = "https://api.peopledatalabs.com/v5/person/identify" # Production Identify API

  # Create a parameters JSON object
  PARAMS = {
    "company": "walmart",
    "pretty": True,
    "api_key": API_KEY
  }

  # Pass the parameters object to the Sandbox Person Identify API
  response = requests.request("GET", PDL_URL, params=PARAMS)

  response_data = response.json()

  # Create a list of matches
  identities = response_data['matches']

  # Print the matches in JSON format
  print(identities)
  print(f"Found {len(identities)} identities!")
  ```
</CodeGroup>

See [Examples - Person Identify API](/docs/identify-api) for additional examples.


## Related topics

- [Reference - Sandbox APIs](/docs/sandbox-apis-reference.md)
- [July 2022 Release Notes](/changelog/july-2022-release-notes-v19.md)
- [Examples - Cleaner APIs](/docs/examples-cleaner-apis.md)
- [Sandbox API Endpoints](/docs/sandbox-apis.md)
- [Example Person Record](/docs/example-record.md)