People Data Labs Rust Client

Official Rust client for the People Data Labs API.

Table of Contents

• 🔧 Installation
• 🚀 Usage
• 🏝 Sandbox Usage
• 🌐 Endpoints
• 📘 Documentation

🔧 Installation

1. To use peopledatalabs-rs SDK in your project initialize your Rust crate then run:

bash cargo add peopledatalabs-rs

1. Sign up for a free PDL API key.
2. Set your API key as a environment variable.

🚀 Usage

First, create the PeopleDataLabs client:

rust let api_key = std::env::var("PDL_API_KEY").unwrap(); let client = PDL::new(&api_key);

Then, send requests to any PDL API Endpoint.

Person Data

Enrichment

```rust let mut personparams = PersonParams::default(); personparams.name = Some(vec!["josh finnie".tostring()]); personparams.location = Some(vec!["washington, dc".to_string()]);

let mut enrichparams = EnrichPersonParams::default(); enrichparams.personparams = personparams.clone();

let results = client.person.enrich(enrich_params); ```

Bulk Enrichment

```rust let mut personparams = PersonParams::default(); personparams.name = Some(vec!["josh finnie".tostring()]); personparams.location = Some(vec!["washington, dc".to_string()]);

let request = BulkEnrichSinglePersonParams { params: personparams.clone(), metadata: None, }; let bulkenrich_params = BulkEnrichPersonParams { requests: vec![request], };

let results = client.person.bulkenrich(bulkenrich_params); ```

Search (Elasticsearch)

```rust let mut searchbaseparams = SearchBaseParams::default(); searchbaseparams.query = Some(serdejson::value::Value::String( "{'bool':{'must': [{'term': {'jobtitlerole': 'health'}},]}}".tostring(), ));

let mut searchparams = SearchParams::default(); searchparams.searchbaseparams = searchbaseparams;

let searchresults = client.person.search(searchparams); ```

Search (SQL)

```rust let query = r#" SELECT * FROM person WHERE locationcountry='mexico' AND jobtitlerole='health' AND phonenumbers IS NOT NULL; "#.tostring(); let mut searchbaseparams = SeachBaseParams::default(); searchbase_params.sql = query;

let mut seachparams = SearchParams::default(); searchparams.searchbaseparams = searchbaseparams;

let searchresults = client.person.searach(seachparams); ```

PDL_ID (Retrieve API)

```rust let retrievepersonparams = RetrievePersonParams { baseparams: None, personid: "82MYIGZzMttzdyKiQBv4ZQ0000".tostring(), };

let retrieveresults = client.person.retrieve(retrieveperson_params); ```

Bulk Retrieve API

```rust let retrieverequest = BulkRetrieveSinglePersonParams { id: "82MYIGZzMttzdyKiQBv4ZQ0000".to_string(), metadata: None, };

let mut bulkretrieveparams = BulkRetrievePersonParams::default(); bulkretrieveparams.requests = vec![retrieve_request];

let bulkretrieveresults = client.person.bulkretrieve(bulkretrieve_params); ```

Fuzzy Enrichment (Identify API)

```rust let mut personparams = PersonParams::default(); personparams.name = Some(vec!["josh finnie".tostring()]); personparams.location = Some(vec!["washington, dc".to_string()]);

let mut identifyparams = IdentifyPersonParams::default(); identifyparams.personparams = personparams.clone();

let identifyresults = client.person.identify(identifyparams); ```

Company Data

Enrichment

```rust let mut companyparams = CompanyParams::default(); companyparams.name = Some("google".to_string());

let enrichparams = EnrichCompanyParams { baseparams: None, companyparams, additionalparams: None, };

let enrichrequest = client.company.enrich(enrichparams); ```

Search (Elasticsearch)

```rust let mut searchbaseparams = SearchBaseParams::default(); searchbaseparams.query = Some(serdejson::value::Value::String( r#"{'query': {'bool': {'must': { {"term": {"tags": "bigdata"}}, {"term": {"industry": "financial services"}}, {"term": {"location.country": "united states"}}, },},}, }"#.tostring(), ));

let mut searchparams = SearchParams::default(); searchparams.searchbaseparams = searchbaseparams;

let searchresults = client.company.search(searchparams); ```

Search (SQL)

```rust let mut searchbaseparams = SearchBaseParams::default(); searchbaseparams.sql = Some("SELECT * FROM company WHERE website='google.com';".to_string());

let searchparams = SearchParams { baseparams: None, searchbaseparams, additional_params: None, };

let searchresults = client.company.search(searchparams); ```

Supporting APIs

Get Autocomplete Suggestions

```rust let autocompletebaseparams = AutocompleteBaseParams{ field: "text".tostring(), text: Some("full".tostring()) }; let autocompleteparams = AutocompleteParams { baseparams: None, autocompletebaseparams, };

let request = client.autocomplete.autocomplete(autocomplete_params); ```

Clean Raw Company Strings

```rust let mut cleanparams = CleanCompanyParams::default(); cleanparams.name = Some("google".to_string());

let cleanresults = client.company.clean(cleanparams); ```

Clean Raw Location Strings

```rust let baseparams = BaseParams::default(); let locationparams = LocationParams { location: Some("New York, NY".tostring()), }; let params = CleanLocationParams { baseparams: None, locationparams, additionalparams: None, };

let results = client.location.clean(params); ```

Clean Raw School Strings

```rust let mut schoolparams = SchoolParams::default(); schoolparams.name = Some("UConn".tostring()); let params = CleanSchoolParams { baseparams: None, schoolparams, additionalparams: None, };

let results = client.school.clean(params); ```

Enrich Job Title

```rust let jobtitlebaseparams = JobTitleBaseParams { jobtitle: Some("software engineer".tostring()), }; let params = JobTitleParams { baseparams: None, jobtitlebase_params, };

let results = client.job_title.get(params); ```

Enrich Skill

```rust let skillbaseparams = SkillBaseParams { skill: Some("python".tostring()), }; let params = SkillParams { baseparams: None, skillbaseparams, };

let results = client.skill.get(params); ```

Enrich IP

```rust let mut ipbaseparams = IPBaseParams::default(); ipbaseparams.ip = Some("72.212.42.169".tostring()); let params = IPParams { baseparams: None, ipbaseparams, };

let results = client.ip.get(params); ```

🏝 Sandbox Usage

rust // To enable sandbox usage, pass in the following options to the PDLClient before building let api_key = std::env::var("PDL_API_KEY").unwrap(); let mut client_options = PDLCLientOptions::default(); client_options.sandbox = true; let client = PDLClient::new(&api_key).options(client_options).build();

🌐 Endpoints

Person Endpoints

| API Endpoint | SDK Function | |----------------------------------------------------------------------------------------|--------------------------------------| | Person Enrichment API | client.person.enrich(params) | | Person Bulk Enrichment API | client.person.bulk_enrich(params) | | Person Search API | client.person.search(params) | | Person Retrieve API | client.person.retrieve(params) | | Person Bulk Retrieve API | client.person.bulk_retrieve(params) | | Person Identify API | client.person.identify(params) |

Company Endpoints

| API Endpoint | SDK Function | | ------------------------------------------------------------------------------------- |---------------------------------| | Company Enrichment API | client.company.enrich(params) | | Company Search API | client.company.search(params) |

Supporting Endpoints

| API Endpoint | SDK Function | | --------------------------------------------------------------------------------------- |---------------------------------| | Autocomplete API | client.autocomplete.autocomplete(params) | | Company Cleaner API | client.company.clean(params) | | Location Cleaner API | client.location.clean(params) | | School Cleaner API | client.school.clean(params) | | Job Title Enrichment API | client.job_title.enrich(params) | | Skill Enrichment API | client.skill.enrich(params) | | IP Enrichment API | client.ip.enrich(params) |

📘 Documentation

All of our API endpoints are documented at: https://docs.peopledatalabs.com/

These docs describe the supported input parameters, output responses and also provide additional technical context.

As illustrated in the Endpoints section above, each of our API endpoints is mapped to a specific method in the API Client. For each of these class methods, all function inputs are mapped as input parameters to the respective API endpoint, meaning that you can use the API documentation linked above to determine the input parameters for each endpoint.