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

# Supporting Endpoints

# Overview

The Autocomplete API and Cleaner APIs are included at no additional charge for all plan types. The Job Title Enrichment APIs and Skill Enrichment APIs require an additional purchase. To learn more, [Talk to an Expert](https://www.peopledatalabs.com/talk-to-sales).

***

## [Autocomplete API](/docs/autocomplete-api)

The Autocomplete API allows you to get suggestions for Search API query values along with the number of available records for each suggestion:

<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 = {
      "field": "school",
      "text": "stanf",
      "size": 10,
      "pretty": True
  }

  # Pass the parameters object to the Autocomplete API
  json_response = CLIENT.autocomplete(**PARAMS).json()

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

  ```bash cURL theme={null}
  curl -X GET -G \
    'https://api.peopledatalabs.com/v5/autocomplete'\
    -H 'X-Api-Key: xxxx' \
    --data-urlencode 'field=school'\
    --data-urlencode 'text=stanf'\
    --data-urlencode 'size=10'
  ```

  ```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 = {
      "field": "school",
      "text": "stanf",
      "size": 10,
      "pretty": true
  }

  // Pass the parameters object to the Autocomplete API
  PDLJSClient.autocomplete(params).then((data) => {
      // Print the API response in JSON format
      console.log(data);
  }).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'

  # Pass parameters to the Autocomplete API
  json_response = Peopledatalabs::Autocomplete.retrieve(field: "school", text: "stanf", size: 10, pretty: true)

  # 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.AutocompleteParams {
          BaseParams: pdlmodel.BaseParams {
              Size: 10,
              Pretty: true,
          },
          AutocompleteBaseParams: pdlmodel.AutocompleteBaseParams {
              Field: "school",
              Text: "stanf",
          },
      }
      
      // Pass the parameters object to the Autocomplete API
      response, err := client.Autocomplete(context.Background(), params)
      // Check for successful response
      if err == nil {
          // Convert the API response to JSON
          jsonResponse, jsonErr := json.Marshal(response)
          // Print the API response
          if (jsonErr == nil) {
              fmt.Println(string(jsonResponse))
          }
      }
  }
  ```

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

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

  # Set the Autocomplete API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/autocomplete"

  # Create a parameters JSON object
  PARAMS = {
      "api_key": API_KEY,
      "field": "school",
      "text": "stanf",
      "size": 10,
      "pretty": True
  }

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

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

***

## [Cleaner APIs](/docs/cleaner-apis)

We provide several Cleaner APIs, which you can use to standardize raw data fields for company, school and location names based on our own internal standardization criteria.

#### Company Cleaner

You can use the Company Cleaner API to standardize company names:

<CodeGroup>
  ```python Python3 SDK theme={null}
  # 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
  QUERY_STRING = {"website":"peopledatalabs.com"}

  # Pass the parameters object to the Company Cleaner API
  response = CLIENT.company.cleaner(**QUERY_STRING)

  # Print the API response
  print(response.text)
  ```

  ```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 queryString = {
    website: "peopledatalabs.com"
  }

  // Pass the parameters object to the Company Cleaner API
  PDLJSClient.company.cleaner(queryString).then((response) => {
    // Print the API response
    console.log(response);
  }).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'

  # Pass parameters to the Company Cleaner API
  response = Peopledatalabs::Cleaner.company(kind: 'website', value: "peopledatalabs.com")

  # Print the API response
  puts response
  ```

  ```go Go 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 parameters JSON object
      queryString := pdlmodel.CleanCompanyParams{Website: "peopledatalabs.com"}

      // Pass the parameters object to the Company Cleaner API
      response, err := client.Company.Clean(context.Background(), queryString)
    
      // Check for successful response
      if err == nil {
          // Print the API response
          fmt.Println(response)
      }  
  }
  ```

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

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

  # Set the Company Cleaner API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/company/clean"

  # Create a parameters JSON object
  QUERY_STRING = {"website":"peopledatalabs.com"}

  # Set headers
  HEADERS = {
      'accept': "application/json",
      'content-type': "application/json",
      'x-api-key': API_KEY
  }

  # Pass the parameters object to the Company Cleaner API
  response = requests.request("GET", PDL_URL, headers=HEADERS, params=QUERY_STRING)

  # Print the API response
  print(response.text)
  ```
</CodeGroup>

#### School Cleaner

You can use the School Cleaner API to standardize school names:

<CodeGroup>
  ```python Python3 SDK theme={null}
  # 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
  QUERY_STRING = {"profile":"linkedin.com/school/ucla"}

  # Pass the parameters object to the School Cleaner API
  response = CLIENT.school.cleaner(**QUERY_STRING)

  # Print the API response
  print(response.text)
  ```

  ```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 queryString = {
    profile:"linkedin.com/school/ucla"
  }

  // Pass the parameters object to the School Cleaner API
  PDLJSClient.school.cleaner(queryString).then((response) => {
    // Print the API response
    console.log(response);
  }).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'

  # Pass parameters to the School Cleaner API
  response = Peopledatalabs::Cleaner.school(kind: 'profile', value: "linkedin.com/school/ucla")

  # Print the API response
  puts response
  ```

  ```go Go 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 parameters JSON object
      queryString := pdlmodel.CleanSchoolParams {
          SchoolParams: pdlmodel.SchoolParams{Profile: "linkedin.com/school/ucla"},
      }
      
      // Pass the parameters object to the School Cleaner API
      response, err := client.School.Clean(context.Background(), queryString)
    
      // Check for successful response
      if err == nil {
          // Print the API response
          fmt.Println(response)
      }  
  }
  ```

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

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

  # Set the School Cleaner API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/school/clean"

  # Create a parameters JSON object
  QUERY_STRING = {"profile":"linkedin.com/school/ucla"}

  # Set headers
  HEADERS = {
      'accept': "application/json",
      'content-type': "application/json",
      'x-api-key': API_KEY
  }

  # Pass the parameters object to the School Cleaner API
  response = requests.request("GET", PDL_URL, headers=HEADERS, params=QUERY_STRING)

  # Print the API response
  print(response.text)
  ```
</CodeGroup>

#### Location Cleaner

You can use the Location Cleaner API to standardize location names:

<CodeGroup>
  ```python Python3 SDK theme={null}
  # 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
  QUERY_STRING = {"location":"239 NW 13th Ave, Portland, Oregon 97209, US"}

  # Pass the parameters object to the Location Cleaner API
  response = CLIENT.location.cleaner(**QUERY_STRING)

  # Print the API response
  print(response.text)
  ```

  ```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 queryString = {
    location:"239 NW 13th Ave, Portland, Oregon 97209, US"
  }

  // Pass the parameters object to the Location Cleaner API
  PDLJSClient.location.cleaner(queryString).then((data) => {
    // Print the API response
    console.log(data);
  }).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'

  # Pass parameters to the Location Cleaner API
  response = Peopledatalabs::Cleaner.location(value: "239 NW 13th Ave, Portland, Oregon 97209, US")

  # Print the API response
  puts response
  ```

  ```go Go 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 parameters JSON object
      queryString := pdlmodel.CleanLocationParams {
          LocationParams: pdlmodel.LocationParams{Location: "239 NW 13th Ave, Portland, Oregon 97209, US"},
      }
      
      // Pass the parameters object to the Location Cleaner API
      response, err := client.Location.Clean(context.Background(), queryString)
    
      // Check for successful response
      if err == nil {
          // Print the API response
          fmt.Println(response)
      }  
  }
  ```

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

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

  # Set the Location Cleaner API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/location/clean"

  # Create a parameters JSON object
  QUERY_STRING = {"location":"239 NW 13th Ave, Portland, Oregon 97209, US"}

  # Set headers
  HEADERS = {
      'accept': "application/json",
      'content-type': "application/json",
      'x-api-key': API_KEY
  }

  # Pass the parameters object to the Location Cleaner API
  response = requests.request("GET", PDL_URL, headers=HEADERS, params=QUERY_STRING)

  # Print the API response
  print(response.text)
  ```
</CodeGroup>

***

## [Job Title Enrichment API](/docs/job-title-enrichment-api)

You can use the Job Title Enrichment API to enrich data on a job title:

<CodeGroup>
  ```python Python3 SDK theme={null}
  # 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
  QUERY_STRING = {"job_title": "supply manager"}

  # Pass the parameters object to the Job Title Enrichment API
  response = CLIENT.job_title(**QUERY_STRING)

  # Print the API response
  print(response.text)
  ```

  ```bash cURL theme={null}
  curl -X GET -G \
    'https://api.peopledatalabs.com/v5/job_title/enrich' \
    -H 'X-Api-Key: YOUR API KEY' \
    --data-urlencode 'job_title=supply manager'
  ```

  ```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 queryString = {jobTitle: "supply manager"}

  // Pass the parameters object to the Job Title API
  PDLJSClient.jobTitle(queryString).then((data) => {
      // Print the API response
      console.log(data);
  }).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'

  # Pass parameters to the Job Title API
  response = Peopledatalabs::JobTitle.retrieve("job_title":"supply manager")

  # Print the API response
  puts response
  ```

  ```go Go 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 parameters JSON object
      queryString := pdlmodel.JobTitleBaseParams{JobTitle: "supply manager"}
      
      params := pdlmodel.JobTitleParams{
          JobTitleBaseParams: queryString,
      }
      
      // Pass the parameters object to the Job Title API
      response, err := client.JobTitle(context.Background(), params)
      // Check for successful response
      if err == nil {
          // Print the API response
          fmt.Println(response)
      }  
  }
  ```

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

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

  # Set the Job Title Enrichment API URL
  PDL_URL = "https://api.peopledatalabs.com/v5/job_title/enrich"

  # Create a parameters JSON object
  QUERY_STRING = {"job_title": "supply manager"}

  # Set headers
  HEADERS = {
      'accept': "application/json",
      'content-type': "application/json",
      'x-api-key': API_KEY
  }

  # Pass the parameters object to the Job Title Enrichment API
  response = requests.request("GET", PDL_URL, headers=HEADERS, params=QUERY_STRING)

  # Print the API response
  print(response.text)
  ```
</CodeGroup>

<br />


## Related topics

- [Endpoints](/docs/endpoints.md)
- [December 2024 Release Notes](/changelog/december-2024-release-notes-v282.md)
- [Reference - Sandbox APIs](/docs/sandbox-apis-reference.md)
- [Reference - Person Changelog API](/docs/reference-person-changelog-api.md)
- [Reference - Autocomplete API](/docs/reference-autocomplete-api.md)