Examples - Cleaner APIs - People Data Labs Documentation

We’ve provided code samples in cURL, Python, Ruby, Go and JavaScript. If you aren’t comfortable working in any of these languages, feel free to use this handy tool to convert code from cURL to the language of your choice.

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 or a feature request and receive automatic notifications as your bug is resolved or your request is implemented.

Company Cleaner API Example

“Show me how this company is stored in PDL based on the website.”

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

curl -X GET -G \
  'https://api.peopledatalabs.com/v5/company/clean' \
  -H 'X-Api-Key: xxxx' \
  --data-urlencode 'website=peopledatalabs.com'

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

// Pass the parameters object to the Company Cleaner API
PDLJSClient.company.cleaner(params).then((data) => {
  // Print the API response
  console.log(data);
}).catch((error) => {
  console.log(error);
});

# 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

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
    params := pdlmodel.CleanCompanyParams {
        Website: "peopledatalabs.com",
    }
    
    // Pass the parameters object to the Company Cleaner API
    response, err := client.Company.Clean(context.Background(), params)
    // Check for successful response
    if err == nil {
        // Print the API response
        fmt.Println(response)
    }  
}

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)

Location Cleaner API Example

“Show me information about this specific location.”

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

curl -X GET -G \
  'https://api.peopledatalabs.com/v5/location/clean' \
  -H 'X-Api-Key: xxxx' \
  --data-urlencode 'location=239 NW 13th Ave, Portland, Oregon 97209, US'

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

// Pass the parameters object to the Location Cleaner API
PDLJSClient.location.cleaner(params).then((data) => {
  // Print the API response
  console.log(data);
}).catch((error) => {
  console.log(error);
});

# 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

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

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)

School Cleaner API Example

“Show me how this school is stored in PDL based on the LinkedIn URL.”

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

curl -X GET -G \
  'https://api.peopledatalabs.com/v5/school/clean' \
  -H 'X-Api-Key: xxxx' \
  --data-urlencode 'profile=linkedin.com/school/ucla'

// 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:"linkedin.com/school/ucla"
}

// Pass the parameters object to the School Cleaner API
PDLJSClient.school.cleaner(params).then((data) => {
  // Print the API response
  console.log(data);
}).catch((error) => {
  console.log(error);
});

# 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

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

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)

Company Cleaner API Example Using POST

“Show me how this company is stored in PDL based on the name using a POST request.”

Difference Between GET and POST RequestsSee this article for a comparison of the differences between GET and POST requests. The biggest difference is that POST requests don’t have any limit on the amount of data that you can pass in a request.

import requests

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

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

# Create a parameters JSON object
QUERY_STRING = {"name":"peopledatalabs"}

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

# Pass the parameters object to the Company Cleaner API using POST method
response = requests.post(
  PDL_URL,
  headers=HEADERS,
  json=QUERY_STRING # Passing the data directly as a JSON object
).json()

# Print the API response
print(response)

curl -X POST \
  'https://api.peopledatalabs.com/v5/company/clean' \
  -H 'X-Api-Key: your-api-key' \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "peopledatalabs",
    "pretty": true
}'

Advanced Example

“I want to find employees at a particular company but don’t have the PDL identifier for the company.”

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

# Set the website of the company you want to search
COMPANY_WEBSITE = "peopledatalabs.com"

# Create a parameters JSON object for the Company Cleaner API
QUERY_STRING = { "website": COMPANY_WEBSITE }

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

# Check for successful response
if response.status_code == 200:
    # Store the cleaned company from the API response
    cleaned_company = response.json()
else:
    cleaned_company = {}
    print(f"Company Cleaner API Error for [{COMPANY_WEBSITE}]: {response.text}")

# Employees at the cleaned company
company_employee_matches = {}

# Check for cleaned company
if cleaned_company:
    # Create an Elasticsearch query
    ES_QUERY = {
        "query": {
            "bool": {
                "must": [
                    {"term": {"job_company_id": cleaned_company['id']}}
                ]
            }
        }
    }

    # Create a parameters JSON object for the Person Search API
    PARAMS = {
        'query': ES_QUERY,
        'size': 100
    }

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

    # Check for successful response
    if response.status_code == 200:
        # Store the employees of the cleaned company from the API 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}.")

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

# Set the website of the company you want to search
COMPANY_WEBSITE = "peopledatalabs.com"

# Create a parameters JSON object for the Company Cleaner API
QUERY_STRING = { "website": COMPANY_WEBSITE }

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

# Check for successful response
if response.status_code == 200:
    # Store the cleaned company from the API response
    cleaned_company = response.json()
else:
    cleaned_company = {}
    print(f"Company Cleaner API Error for [{COMPANY_WEBSITE}]: {response.text}")

# Employees at the cleaned company
company_employee_matches = {}

# Check for cleaned company
if cleaned_company:
    # Create an SQL query
    SQL_QUERY = f"""
    SELECT * FROM person
    WHERE job_company_id = '{cleaned_company['id']}'
    """

    # Create a parameters JSON object for the Person Search API
    PARAMS = {
        'sql': SQL_QUERY,
        'size': 100
    }

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

    # Check for successful response
    if response.status_code == 200:
        # Store the employees of the cleaned company from the API 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}.")

// 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" });

// Set the website of the company you want to search
const companyWebsite = "peopledatalabs.com";

// Create a parameters JSON object for the Company Cleaner API
const queryString = { "website": companyWebsite };

// The cleaned company
var cleanedCompany;

// Pass the parameters object to the Company Cleaner API
PDLJSClient.company.cleaner(queryString).then((data) => {

    // Store the cleaned company from the API response
    cleanedCompany = data;
    
    // Employees at the cleaned company
    var companyEmployeeMatches = {};
    
    // Create an Elasticsearch query
    const esQuery = {
      query: {
         bool: {
            must:[
               {"term": {"job_company_id": cleanedCompany["id"]}}
            ]
         }
      }
    }
    
    // Create a parameters JSON object for the Person Search API
    const params = {
        searchQuery: esQuery, 
        size: 100,
    }
    
    // Pass the parameters object to the Person Search API
    PDLJSClient.person.search.elastic(params).then((data) => {
        // Store the employees of the cleaned company from the API response
        companyEmployeeMatches = data.data;
        console.log(`Found ${companyEmployeeMatches.length} employee profiles at ${companyWebsite}.`);
    }).catch((error) => {
        companyEmployeeMatches = {};
        console.log(`Person Search Error for [${companyWebsite}]: ${error}`);
    });
    
}).catch((error) => {
    console.log(error);
});

// 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" });

// Set the website of the company you want to search
const companyWebsite = "peopledatalabs.com";

// Create a parameters JSON object for the Company Cleaner API
const queryString = { "website": companyWebsite };

// The cleaned company
var cleanedCompany;

// Pass the parameters object to the Company Cleaner API
PDLJSClient.company.cleaner(queryString).then((data) => {

    // Store the cleaned company from the API response
    cleanedCompany = data;
    
    // Employees at the cleaned company
    var companyEmployeeMatches = {};
    
    // Create an SQL query
    const sqlQuery = `SELECT * FROM person
                        WHERE job_company_id = '` + cleanedCompany["id"] + `';`;
    
    // Create a parameters JSON object for the Person Search API
    const params = {
        searchQuery: sqlQuery, 
        size: 100,
    }
    
    // Pass the parameters object to the Person Search API
    PDLJSClient.person.search.sql(params).then((data) => {
        // Store the employees of the cleaned company from the API response
        companyEmployeeMatches = data.data;
        console.log(`Found ${companyEmployeeMatches.length} employee profiles at ${companyWebsite}.`);
    }).catch((error) => {
        companyEmployeeMatches = {};
        console.log(`Person Search Error for [${companyWebsite}]: ${error}`);
    });
    
}).catch((error) => {
    console.log(error);
});

require 'json'

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

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

# Set the website of the company you want to search
COMPANY_WEBSITE = "peopledatalabs.com"

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

# Check for successful response
if response['status'] == 200
    # Store the cleaned company from the API response
    cleaned_company = response
else
    cleaned_company = {}
    puts "Company Cleaner API Error for #{COMPANY_WEBSITE}: #{response}"
end

# Employees at the cleaned company
company_employee_matches = {}

# Check for cleaned company
if cleaned_company
    # Create an Elasticsearch query
    ES_QUERY = {
        "query": {
            "bool": {
                "must": [
                    {"term": {"job_company_id": cleaned_company['id']}}
                ]
            }
        }
    }

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

    # Check for successful response
    if response['status'] == 200
        # Store the employees of the cleaned company from the API 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}."

require 'json'

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

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

# Set the website of the company you want to search
COMPANY_WEBSITE = "peopledatalabs.com"

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

# Check for successful response
if response['status'] == 200
    # Store the cleaned company from the API response
    cleaned_company = response
else
    cleaned_company = {}
    puts "Company Cleaner API Error for #{COMPANY_WEBSITE}: #{response}"
end

# Employees at the cleaned company
company_employee_matches = {}

# Check for cleaned company
if cleaned_company
    # Create an SQL query
    SQL_QUERY = """
    SELECT * FROM person
    WHERE job_company_id = '#{cleaned_company['id']}'
    """

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

    # Check for successful response
    if response['status'] == 200
        # Store the employees of the cleaned company from the API 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}."

package main

import (
    "fmt"
    "encoding/json"
    "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)
    
    // Set the website of the company you want to search
    companyWebsite := "peopledatalabs.com"

    // Create a parameters JSON object for the Company Cleaner API
    cleanParams := pdlmodel.CleanCompanyParams {
        Website: "peopledatalabs.com",
    }
    
    // The cleaned company
    var cleanedCompany pdlmodel.CleanCompanyResponse
    
    // Pass the parameters object to the Company Cleaner API
    cleanResponse, cleanErr := client.Company.Clean(context.Background(), cleanParams)
    // Check for successful response
    if cleanErr == nil {
        // Store the cleaned company from the API response
        cleanedCompany = cleanResponse
    } else {
        fmt.Printf("Company Cleaner API Error for [%s]: %s", companyWebsite, cleanResponse)
    }
    
    // Check for cleaned company
    if !reflect.ValueOf(cleanedCompany).IsZero() {
        // 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": cleanedCompany.Id}},
                    },
                },
            },
        }

        // Create a parameters JSON object for the Person Search API
        searchParams := pdlmodel.SearchParams {
            BaseParams: pdlmodel.BaseParams {
                Size: 100,
            },
            SearchBaseParams: pdlmodel.SearchBaseParams {
                Query: elasticSearchQuery,
            },
        }
        
        // Pass the parameters object to the Person Search API
        SearchResponse, SearchErr := client.Person.Search(context.Background(), searchParams)
        // Check for successful response
        if SearchErr == nil {
            data := SearchResponse.Data
            // Store the employees of the cleaned company from the API response in JSON format
            companyEmployeeMatches, jsonErr := json.Marshal(data)
     
            if jsonErr == nil && !reflect.ValueOf(companyEmployeeMatches).IsZero() {
                fmt.Printf("Found %d employee profiles at %s.\n", len(data), companyWebsite)
            }
        } else {
            fmt.Printf("Company Cleaner API Error for [%s]: %s\n", companyWebsite, SearchResponse)
        }
    }
}

package main

import (
    "fmt"
    "encoding/json"
    "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)
    
    // Set the website of the company you want to search
    companyWebsite := "peopledatalabs.com"

    // Create a parameters JSON object for the Company Cleaner API
    cleanParams := pdlmodel.CleanCompanyParams {
        Website: "peopledatalabs.com",
    }
    
    // The cleaned company
    var cleanedCompany pdlmodel.CleanCompanyResponse
    
    // Pass the parameters object to the Company Cleaner API
    cleanResponse, cleanErr := client.Company.Clean(context.Background(), cleanParams)
    // Check for successful response
    if cleanErr == nil {
        // Store the cleaned company from the API response
        cleanedCompany = cleanResponse
    } else {
        fmt.Printf("Company Cleaner API Error for [%s]: %s", companyWebsite, cleanResponse)
    }
    
    // Check for cleaned company
    if !reflect.ValueOf(cleanedCompany).IsZero() {
        // Create an SQL query
        sqlQuery := "SELECT * FROM person" +
            " WHERE job_company_id='" + cleanedCompany.Id + "';"

        // Create a parameters JSON object for the Person Search API
        searchParams := pdlmodel.SearchParams {
            BaseParams: pdlmodel.BaseParams {
                Size: 100,
            },
            SearchBaseParams: pdlmodel.SearchBaseParams {
                SQL: sqlQuery,
            },
        }
        
        // Pass the parameters object to the Person Search API
        SearchResponse, SearchErr := client.Person.Search(context.Background(), searchParams)
        // Check for successful response
        if SearchErr == nil {
            data := SearchResponse.Data
            // Store the employees of the cleaned company from the API response in JSON format
            companyEmployeeMatches, jsonErr := json.Marshal(data)
     
            if jsonErr == nil && !reflect.ValueOf(companyEmployeeMatches).IsZero() {
                fmt.Printf("Found %d employee profiles at %s.\n", len(data), companyWebsite)
            }
        } else {
            fmt.Printf("Company Cleaner API Error for [%s]: %s\n", companyWebsite, SearchResponse)
        }
    }
}

import json
import requests

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

# Set the Company Cleaner API URL
PDL_COMPANY_CLEANER_URL = "https://api.peopledatalabs.com/v5/company/clean"
# Set the Person Search API URL
PDL_PERSON_SEARCH_URL = "https://api.peopledatalabs.com/v5/person/search"

# Set the website of the company you want to search
COMPANY_WEBSITE = "peopledatalabs.com"

# Create a parameters JSON object for the Company Cleaner 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 Cleaner API
response = requests.request("GET", PDL_COMPANY_CLEANER_URL, headers=HEADERS, params=QUERY_STRING)

# Check for successful response
if response.status_code == 200:
    # Store the cleaned company from the API response
    cleaned_company = response.json()
else:
    cleaned_company = {}
    print(f"Company Cleaner API Error for [{COMPANY_WEBSITE}]: {response.text}")

# Employees at the cleaned company
company_employee_matches = {}

# Check for cleaned company
if cleaned_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": cleaned_company['id']}}
                ]
            }
        }
    }

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

    # 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:
        # Store the employees of the cleaned company from the API 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}.")

import json
import requests

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

# Set the Company Cleaner API URL
PDL_COMPANY_CLEANER_URL = "https://api.peopledatalabs.com/v5/company/clean"
# Set the Person Search API URL
PDL_PERSON_SEARCH_URL = "https://api.peopledatalabs.com/v5/person/search"

# Set the website of the company you want to search
COMPANY_WEBSITE = "peopledatalabs.com"

# Create a parameters JSON object for the Company Cleaner 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 Cleaner API
response = requests.request("GET", PDL_COMPANY_CLEANER_URL, headers=HEADERS, params=QUERY_STRING)

# Check for successful response
if response.status_code == 200:
    # Store the cleaned company from the API response
    cleaned_company = response.json()
else:
    cleaned_company = {}
    print(f"Company Cleaner API Error for [{COMPANY_WEBSITE}]: {response.text}")

# Employees at the cleaned company
company_employee_matches = {}

# Check for cleaned company
if cleaned_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 = '{cleaned_company['id']}'
    """

    # Create a parameters JSON object for the Person Search API
    PARAMS = {
        'sql': SQL_QUERY,
        'size': 100
    }

    # 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:
        # Store the employees of the cleaned company from the API 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}.")

General

API Overview

Person Data

Person APIs

Company Data

Company APIs

IP Data

IP API

Job Posting Data

Job Posting API

Supporting APIs

Data Standardization

Free Datasets

Libraries

Integrations

Resources

Data License

Support

Examples - Cleaner APIs

Company Cleaner API Example

Location Cleaner API Example

School Cleaner API Example

Company Cleaner API Example Using POST

Advanced Example

​Company Cleaner API Example

​Location Cleaner API Example

​School Cleaner API Example

​Company Cleaner API Example Using POST

​Advanced Example

Company Cleaner API Example

Location Cleaner API Example

School Cleaner API Example

Company Cleaner API Example Using POST

Advanced Example