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

# Person Endpoints

## The Differences Between Our Person-Related APIs

We offer multiple person-related APIs, so how are they different? Here's a summary of each:

**Person Enrichment**: Finds the single best profile matching certain attributes about a particular person.

**Person Search**: Finds all the profiles for any number of persons that satisfy some search criteria.

**Person Identify**: Finds the best selection of profiles associated with a particular set of attributes for a person or related persons.

Here's a table that summarizes some of the key differences:

|                                         | Person Enrichment                                         | Person Identify                                                     | Person Search                  |
| --------------------------------------- | --------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------ |
| **Matching Type**                       | 1:1                                                       | 1:Many                                                              | 1:Many                         |
| **Input Cleaning**                      | Yes                                                       | Yes                                                                 | No                             |
| **Supported Query Parameters**          | Only supported inputs, which must be uniquely identifying | Only supported inputs, which do not need to be uniquely identifying | Anything in the Person Schema  |
| **Number of Profiles per Unique Query** | 1                                                         | Up to 20                                                            | No limit                       |
| **Sorting of Returned Profiles**        | N/A - only the single best-matched profile is returned    | Sorted by match score                                               | Sorted by profile completeness |

The key takeaway is that the **Person Identify API exists between our Person Enrichment and Search APIs** in terms of functionality.

Compared to the Person Enrichment API, which returns a single record for a single person, the **Person Identify API supports broader search inputs and returns multiple strongly-related profiles**. This means that the Person Identify API is ideal for situations in which you do not have enough information to uniquely resolve a person and are interested in recovering highly-probable candidates. The Person Enrichment API is better suited to targeted enrichment when you have enough uniquely-identifying information.

Compared to the Person Search API, the **Person Identify API has standardized input parameters and provides a match score for each returned profile.** This means that you can use the Person Identify API to recover a focused selection of highly related profiles, unlike the Person Search API, which will return a potentially large demographic cross-section of our Person Dataset with more loosely-related profiles.

## [Person Enrichment API](/docs/person-enrichment-api)

You can use the Person Enrichment API to enrich data on a person:

<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",
  )

  # Create a parameters JSON object
  PARAMS = {
      "profile": ["linkedin.com/in/seanthorne"]
  }

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

  # Print the API response in JSON format
  print(json_response)
  ```

  ```bash cURL theme={null}
  curl -X GET \
    'https://api.peopledatalabs.com/v5/person/enrich?api_key=xxxx&profile=linkedin.com/in/seanthorne'
  ```

  ```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 = {
    profile: "http://linkedin.com/in/seanthorne"
  }

  // Pass the parameters object to the Person Enrichment API
  PDLJSClient.person.enrichment(params).then((jsonResponse) => {
    // Print the API response in JSON format
    console.log(jsonResponse);
  }).catch((error) => {
    console.log(error);
  });
  ```

  ```ruby Ruby 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 parameters JSON object
  PARAMS = {
      profile: ['linkedin.com/in/seanthorne']
  }

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

  # Print the API response in JSON format
  puts JSON.dump(json_response)
  ```

  ```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"
      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 parameters JSON object
      params := pdlmodel.EnrichPersonParams {
          PersonParams: pdlmodel.PersonParams {
              Profile: []string{"linkedin.com/in/seanthorne"},
          },
      }

      // Pass the parameters object to the Person Enrichment API
      response, err := client.Person.Enrich(context.Background(), params)
      
      // Convert the API response to JSON
      jsonResponse, jsonErr := json.Marshal(response.Data)

      // Print the API response
      if err == nil && jsonErr == nil {
          fmt.Println(string(jsonResponse))
      }  
  }
  ```

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

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

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

  # Create a parameters JSON object
  PARAMS = {
      "api_key": API_KEY,
      "profile": ["linkedin.com/in/seanthorne"]
  }

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

  # Print the API response in JSON format
  print(json_response)
  ```
</CodeGroup>

## [Bulk Person Enrichment API](/docs/bulk-enrichment-api)

We also provide a Bulk Person Enrichment API, which allows you to enrich 1-100 persons in a single request (recommended for high-volume 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",
  )

  # Create an array of parameters JSON objects
  DATA = {"requests": [{"params": {"profile": ["linkedin.com/in/seanthorne"]}}]}

  # Pass the bulk parameters object to the Bulk Person Enrichment API
  json_response = CLIENT.person.bulk(**DATA).json()

  # Print the API response in JSON format
  print(json_response)
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.peopledatalabs.com/v5/person/bulk" -H 'X-Api-Key: xxxx' 'Content-Type: application/json' -d'
  {
      "requests": [
      	{
      		"params": {
      			"profile": ["linkedin.com/in/seanthorne"]
      		}
      	}
      ]
  }
  ```

  ```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 an array of parameters JSON objects
  const data = {
    requests: [
      {
        params: {
          profile: ['linkedin.com/in/seanthorne']
        }
      }
    ]
  };

  // Pass the parameters object to the Bulk Person Enrichment API
  PDLJSClient.person.bulk(data).then((jsonResponse) => {
    // Print the API response in JSON format
    console.log(jsonResponse);
  }).catch((error) => {
    console.log(error);
  });
  ```

  ```ruby Ruby 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 array of parameters JSON objects
  DATA = {requests: [{params: {profile: ['linkedin.com/in/seanthorne']}}]}

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

  # Print the API response in JSON format
  puts JSON.dump(json_response)
  ```

  ```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"
      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 array of parameters JSON objects
      params := pdlmodel.BulkEnrichPersonParams {
          Requests: []pdlmodel.BulkEnrichSinglePersonParams {
              {
                  Params: pdlmodel.PersonParams {
                      Profile:  []string{"linkedin.com/in/seanthorne"},
                  },
              },
          },
      }

      // Pass the parameters object to the Bulk Person Enrichment API
      response, err := client.Person.BulkEnrich(context.Background(), params)
      
      // Convert the API response to JSON
      jsonResponse, jsonErr := json.Marshal(response)

      // Print the API response
      if err == nil && jsonErr == nil {
          fmt.Println(string(jsonResponse))
      }  
  }
  ```

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

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

  # Set the Bulk Person Enrichment API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/person/bulk"

  # Pass your API key in header
  HEADERS = {
      'X-Api-Key': API_KEY,
      'Content-Type': 'application/json'
  }

  # Create an array of parameters JSON objects
  DATA = '{"requests": [{"params": {"profile": ["linkedin.com/in/seanthorne"]}}]}'

  # Pass the bulk parameters object to the Bulk Person Enrichment API
  json_response = requests.post(PDL_URL, headers=HEADERS, data=DATA).json()

  # Print the API response in JSON format
  print(json_response)
  ```
</CodeGroup>

## [Person Search API](/docs/person-search-api)

You can use the Person Search API to write queries (in either Elasticsearch or SQL format) against our Person Dataset and return the profiles that match those queries:

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

## [Person Identify API](/docs/person-identify-api)

You can use the Person Identify API to access multiple strongly-associated profiles based on some broadly identifying criteria (such as a name or a street address):

<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",
  )

  # Create a parameters JSON object
  PARAMS = {
   "first_name": "sean", 
   "last_name": "thorne", 
   "company": "people data labs",
   "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!")
  ```

  ```bash cURL theme={null}
  API_KEY="ENTER YOUR API KEY HERE"
  curl -X GET -G \
   "https://api.peopledatalabs.com/v5/person/identify"\
   -H "X-Api-Key: ${API_KEY}" \
   --data-urlencode 'first_name=sean'\
   --data-urlencode 'last_name=thorne'\
   --data-urlencode 'company="people data labs"'\
   --data-urlencode 'pretty=True'
  ```

  ```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 = {
    first_name: "sean", 
    last_name: "thorne", 
    company: "people data labs",
    pretty: 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'

  # Create a parameters JSON object
  PARAMS = {
   "first_name": "sean", 
   "last_name": "thorne", 
   "company": "people data labs",
   "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 JSON.dump(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"
      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 parameters JSON object
      params := pdlmodel.IdentifyPersonParams {
          BaseParams: pdlmodel.BaseParams {
              Pretty: true,
          },
          PersonParams: pdlmodel.PersonParams {
              FirstName: []string{"sean"},
              LastName: []string{"thorne"},
              Company: []string{"people data labs"},
          },
      }
      
      // 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))
      }
  }
  ```

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

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

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

  # Create a parameters JSON object
  PARAMS = {
   "first_name": "sean", 
   "last_name": "thorne", 
   "company": "people data labs",
   "pretty": True,
   "api_key": API_KEY
  }

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


## Related topics

- [Endpoints](/docs/endpoints.md)
- [July 2022 Release Notes](/changelog/july-2022-release-notes-v19.md)
- [Company Endpoints](/docs/company-endpoints.md)
- [IP Endpoint](/docs/ip-endpoint.md)
- [Sandbox API Endpoints](/docs/sandbox-apis.md)