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

# Entity resolution techniques

> Techniques for cleaning, standardizing, and matching records, how to combine them into a matching pipeline, and how to evaluate the results.

Entity resolution is the process of deciding whether two or more records describe the same real-world person, company, or place. It's the foundation for deduplicating your data and for linking your records to other datasets, including PDL's.Real-world data is messy. Typos, inconsistent formats, nicknames, and missing fields are the norm. No single technique handles all of it, so effective matching pipelines layer several together.<ul /><ol aria-label="Entity resolution steps" />Resolved entityRobert SmithLinked source records:Three source records resolve to one entity when enough evidence supports the match. The source records stay intact; the entity links them.Resolving records isn't the same as merging them:- **Record linking** establishes that records refer to the same entity, usually by assigning them a shared entity ID.
- **Record merging** combines linked records into one consolidated representation.You can link without merging. Many teams keep the original source records, their provenance, and any conflicting values, so they can audit or undo a link later.## Three categories of techniquesThis guide covers 11 techniques in three groups.> [card] [Prepare your data](#part-1-prepare-your-data)
>
> Clean, normalize, and structure your records so you can compare them reliably.> [card] [Match on identity signals](#part-2-match-on-identity-signals)
>
> Find matching entities with shared identifiers and combinations of identifying attributes.> [card] [Match on similarity](#part-3-match-on-similarity)
>
> Find potential matches when records are incomplete, inconsistent, or approximate.***## Recommended workflowMost matching pipelines follow the same general shape. Treat this as a starting point, not a fixed sequence. Not every pipeline needs every technique.```mermaid theme={null}
flowchart TD
    A["Raw input records"] --> B["Prepare: clean, standardize, parse"]
    B --> C{{"Reliable shared identifier?"}}
    C -- "Yes" --> D["Link on the identifier"]
    C -- "No" --> E["Generate candidate pairs (blocking)"]
    E --> F["Compare candidates: composite keys, rules, similarity"]
    D --> G{{"Assess match confidence"}}
    F --> G
    G -- "High" --> H["Accept the link"]
    G -- "Medium" --> I["Send to review"]
    G -- "Low" --> J["Leave unresolved"]
```A few principles apply at every step:- **Start simple.** Use reliable, inexpensive techniques such as exact identifier matches first. Save sophisticated techniques for the records that remain unresolved.
- **Treat every signal as evidence, not proof.** A shared name, address, phone number, or domain can be a coincidence, and so can a high similarity score. Link records when several independent signals agree and none conflict.
- **Set decision rules on purpose.** Choose thresholds based on how much a wrong match costs you. See [Evaluating match quality](#evaluating-match-quality).
- **Review the middle.** Send borderline matches to review rather than linking them automatically.### Worked exampleHere's how the techniques build on each other for two records that describe the same person.| Record | Name | Company | Phone |
| :- | :- | :- | :- |
| A | Robert Smith | Acme Inc. | (415) 555-0132 |
| B | Bob Smith | ACME Incorporated | +1 415-555-0132 |**1. Standardize**Both phone numbers normalize to `+14155550132`. Company names normalize to `acme` once you lowercase them and set aside legal suffixes. See [Standardization](#2-standardization-and-normalization).**2. Map nicknames**"Bob" is a common nickname for "Robert," so the first names are compatible. See [Nicknames](#6-nicknames-and-name-variations).\**3. Evaluate the signals*\*\\<table><thead><tr><th scope="col">Attribute</th>
\\<th scope="col">Record A</th>
\\<th scope="col">Record B</th>
\\<th scope="col">Signal</th></tr></thead>
\\<tbody /></table>\\**Decision:** Strong match candidate. Several independent signals agree, and none conflict.No single signal here proves identity. "Smith" is common, and phone numbers get reassigned. The combination is what makes the link credible.***## Technique quick referenceFind your data problem, then jump to the technique. The roles are typical uses, not the only ones.| If your data has... | Technique | Typical role |
| :- | :- | :- |
| Duplicate rows or malformed values | [1. Cleaning and preprocessing](#1-data-cleaning-and-preprocessing) | Data preparation |
| Inconsistent formatting | [2. Standardization](#2-standardization-and-normalization) | Data preparation |
| Multiple attributes in one field | [3. Parsing](#3-parsing-and-decomposition) | Data preparation |
| Shared identifiers across sources | [4. Unique identifiers](#4-unique-identifiers) | Matching |
| Several partially reliable attributes | [5. Composite keys](#5-cross-field-matching-with-composite-keys) | Matching |
| Informal names or aliases | [6. Nicknames and variations](#6-nicknames-and-name-variations) | Candidate generation |
| Different address representations | [7. Geocoding](#7-geocoding-and-location-matching) | Supporting signal |
| Inconsistent company information | [8. Rule-based matching](#8-custom-rules-for-business-data) | Matching |
| Names that sound alike | [9. Phonetic algorithms](#9-phonetic-algorithms) | Candidate generation |
| Typos or spelling differences | [10. Fuzzy matching](#10-fuzzy-matching) | Similarity scoring |
| Complex or ambiguous record pairs | [11. Machine learning](#11-machine-learning-approaches) | Match classification |***## Part 1: Prepare your data### 1. Data cleaning and preprocessingRemove duplicate rows and fix obvious errors *before* you try to match anything. Otherwise, the same mistake carries into every later step.**Example dataset**| Unique ID | Name | Email |
| :- | :- | :- |
| 1 | Alice Johnson | [alice@example.com](mailto:alice@example.com) |
| 2 | Bob Smith | [bob.smith@example.com](mailto:bob.smith@example.com) |
| 3 | Alice Johnson | [alice@example.com](mailto:alice@example.com) |
| 4 | Charlie Brown | [charlie@sample.net](mailto:charlie@sample.net) |
| 5 | Bbo Smith | [bob.smith@example.com](mailto:bob.smith@example.com) |**Issues**- IDs 1 and 3 are duplicate rows for Alice Johnson.
- ID 5 has a typo: "Bbo Smith" should be "Bob Smith."**Solution**- Remove rows that are identical on every field, such as IDs 1 and 3.
- Prefer linking over deleting when rows share only some values, such as the email on IDs 2 and 5. Different people can share an inbox.
- Flag likely typos for manual review instead of correcting them automatically. Many names aren't dictionary words, so a spell-checker can "fix" a name that was already correct.IDs 2 and 5 aren't duplicate rows. They're two rows that probably describe the same *entity*, and the shared email is what reveals it. Matching on email catches a typo that name matching alone would miss.Keep the original values alongside your cleaned ones. You'll need them to audit matches and to recover from a correction that turns out to be wrong.### 2. Standardization and normalizationThe same value can be written many ways. Convert everything to one consistent format so you can compare records directly.Raw values<ul />E.164 format`+14155550132`The first two numbers have no country code, so this assumes they're US numbers.* **Phone numbers:** convert to [E.164](https://en.wikipedia.org/wiki/E.164) format. Numbers without a country code need a default region, so record which region you assumed.
* **Addresses:** use consistent abbreviations and country codes. For example, "123 Main Street, Anytown, US" and "123 Main St., Anytown, U.S.A." become the same value.> [accordion] Example: normalize phone numbers in Python
>
> The [`phonenumbers`](https://pypi.org/project/phonenumbers/) Python library handles parsing and formatting:
>
> ```bash theme={null}
> pip install phonenumbers
> ```
>
> ```python Normalize phone numbers theme={null}
> import phonenumbers
>
> raw_numbers = ["(415) 555-0132", "415.555.0132", "+1 415-555-0132"]
>
> for raw in raw_numbers:
>     # "US" applies only when the number has no country code.
>     number = phonenumbers.parse(raw, "US")
>     print(phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164))
> ```
>
> ```text Output theme={null}
> +14155550132
> +14155550132
> +14155550132
> ```
>
> `phonenumbers.parse` raises `NumberParseException` on values it can't parse, so catch it and keep the raw value for review.Avoid transformations that throw away meaningful differences. Stripping "Apt 12B" from an address makes two different households look identical. Standardize into a new field and keep the original.For addresses, use an address standardization API or library. For PDL's company, school, and location names, the [Cleaner APIs](https://docs.peopledatalabs.com/docs/cleaner-apis) return the standardized values PDL uses.### 3. Parsing and decompositionSplitting a combined value into its components makes each part comparable on its own.**Email example**| Original | First name | Last name | Domain |
| :- | :- | :- | :- |
| [john.doe@corporation.org](mailto:john.doe@corporation.org) | John | Doe | corporation.org |**Address example**| Original | Street | Apartment | City | State | ZIP |
| :- | :- | :- | :- | :- | :- |
| 456 Elm St Apt 12B, Metropolis, NY 10001 | 456 Elm St | Apt 12B | Metropolis | NY | 10001 |**Implementation:** use regular expressions or a parsing library. For emails, split at the `@` symbol, then parse the local part for name patterns.> [!WARNING]
>
> Name patterns in email addresses are a hint, not a fact. Addresses like `jdoe@` or `info@` won't parse into a name, so treat parsed names as lower confidence than names from a dedicated field.***## Part 2: Match on identity signals### 4. Unique identifiersWhen both datasets share a reliable identifier, match on it directly. This is the fastest and highest-confidence approach.**Dataset A**| Unique ID | Name |
| :- | :- |
| A1001 | Laura Martin |
| A1002 | Peter Griffin |
| A1003 | Susan Lee |**Dataset B**| Unique ID | Email |
| :- | :- |
| A1002 | [peter@example.com](mailto:peter@example.com) |
| A1003 | [susan.lee@example.com](mailto:susan.lee@example.com) |
| A1004 | [laura.martin@example.ca](mailto:laura.martin@example.ca) |Joining on Unique ID links A1002 and A1003. A1004 exists only in Dataset B, so it's a new record.A1001 (Laura Martin) and A1004 ([laura.martin@example.ca](mailto:laura.martin@example.ca)) are probably the same person, but the IDs don't match. A unique ID only tells you what *does* match. Records that don't join may still be candidates for the fuzzier techniques below\.An identifier only works when both sources use the same namespace. Customer ID `A1002` in your CRM and `A1002` in a vendor file may refer to different people. Emails and profile URLs are strong signals, but they aren't always unique or permanent. People share inboxes, change jobs, and update their profile URLs.**Implementation:** normalize the identifier on both sides, then join on it. Before you accept the results, check for identifiers that match more than one record on either side. Those aren't clean one-to-one links, and they usually point to duplicates in one of the sources.### 5. Cross-field matching with composite keysWhen no single field is reliable, combine several. A composite key is unlikely to collide by chance, even if each field alone is ambiguous.**Example**| Record | First name | Last name | Date of birth |
| :- | :- | :- | :- |
| 1 | Annie | Hall | 1990-05-15 |
| 2 | Anne | Hall | 15/05/1990 |**Solution**1) Standardize dates to `YYYY-MM-DD`.
2) Build a composite key from first name + last name + date of birth.
3) Account for first-name variations ("Annie" and "Anne"), as covered in the [next section](#6-nicknames-and-name-variations).Composite keys are only as good as the fields inside them. Plan for three failure modes:- **Collisions:** common names and shared birthdays still produce false matches in large datasets.
- **Missing attributes:** a record without a date of birth can't form the key. Decide whether to skip it or fall back to a weaker key.
- **Conflicts:** if names match but dates of birth differ, treat that as evidence *against* the match, not as missing data.### 6. Nicknames and name variationsPeople rarely use their formal name everywhere. Map nicknames to a common form and allow for small misspellings.Names as recorded<ul />Comparison key`william thomson`Bill and Billy map to William, and Thompson is reconciled with Thomson. The key is for comparison only. Keep each record's name as recorded.**Solution**- **Nickname mapping:** "Bill" and "Billy" both map to "William."
- **Spelling correction:** reconcile "Thompson" and "Thomson."
- **Fuzzy matching on last name:** catch remaining minor differences.Treat a nickname mapping as a *possible* alias, not a fact. "Bill" usually means William, but someone named Bill may have no other name. Some nicknames, such as "Alex," map to several formal names. Use the mapping to generate candidates, then confirm with other signals.**Implementation:** maintain a nickname dictionary that maps informal names to formal names, and use a spelling correction algorithm for last names.### 7. Geocoding and location matchingTwo addresses can look different but point to the same place. Converting them to coordinates makes them directly comparable.**Example**| Dataset | Address |
| :- | :- |
| A | 789 Pine Road, Smallville, KS |
| B | 789 Pine Rd, Smallville, Kansas |A geocoding service converts both to the same latitude and longitude, so you can treat them as one location.**Implementation**- Use a geocoding API such as Google Maps or OpenStreetMap.
- Compare coordinates within an acceptable margin of error.
- For US metros and cities, use PDL's [canonical location data](https://docs.peopledatalabs.com/docs/location-metros.md) to keep place names consistent.Treat a shared location as a supporting signal, since family members, roommates, and companies in the same building share addresses.### 8. Custom rules for business dataFor company records, rule-based matching that combines several signals is often more reliable than any single similarity score.

\<table><thead><tr><th scope="col">Attribute</th>
              \<th scope="col">Record A</th>
              \<th scope="col">Record B</th>
              \<th scope="col">Signal</th></tr></thead>
          \<tbody /></table>


      

\**Decision:** Strong match candidate. The LinkedIn URL, website, and phone number agree.

**Rules**- Normalize legal suffixes like "LLC" and "Limited" before comparing names.
- Normalize websites by removing the protocol, `www.`, and trailing paths.
- Normalize phone numbers to E.164.
- Prioritize unique keys such as LinkedIn URL and LinkedIn ID.
- If the normalized phone number and website both match, treat the records as a strong match candidate. Check for a parent or subsidiary relationship before you link them.Suffix normalization helps comparison, but it doesn't establish legal equivalence. "Tech Solutions LLC" and "Tech Solutions Limited" can be separate legal entities in different countries, and subsidiaries often share a parent's domain.**Implementation:** define a rule set specific to business naming conventions and contact details, and apply it inside your matching logic.***## Part 3: Match on similarity### 9. Phonetic algorithmsPhonetic algorithms convert names into codes based on how they sound. Names with the same code are potential matches, even when spelled differently.**Example: Double Metaphone**| Name | Code |
| :- | :- |
| Steven Clark | STFN KLRK |
| Stephen Clarke | STFN KLRK |The codes match, so the records are flagged as potential matches.**Implementation:** use a phonetic encoding library to generate codes, then compare them. Phonetic codes also make good [blocking keys](#matching-at-scale).Most phonetic algorithms were designed for English pronunciation. They work less well for names from other languages and for names transliterated from other scripts, so test them on a sample of your own data.Use phonetic matches to find candidates, then confirm them with a second signal such as email or location.### 10. Fuzzy matchingFuzzy matching measures how *close* two strings are. It catches typos and transpositions that exact matching misses.**Example: edit distance**Edit distance counts the smallest number of single-character edits that turn one string into the other.| Step | String | Edit |
| :- | :- | :- |
| Start | `Micheal Johnson` | |
| 1 | `Michael Johnson` | Transpose the adjacent `e` and `a` |
| 2 | `Michael Jonson` | Delete the `h` |The Damerau-Levenshtein distance is 2, because it counts a transposition as one edit. Standard Levenshtein distance counts a transposition as two edits, so it reports 3. Check which variant your library uses before you set a threshold.> [accordion] Example: compare two names with RapidFuzz
>
> The [RapidFuzz](https://pypi.org/project/RapidFuzz/) Python library computes both distances and a normalized similarity score:
>
> ```bash theme={null}
> pip install rapidfuzz
> ```
>
> ```python Compare two names theme={null}
> from rapidfuzz import fuzz
> from rapidfuzz.distance import DamerauLevenshtein, Levenshtein
>
> a, b = "Micheal Johnson", "Michael Jonson"
>
> print(DamerauLevenshtein.distance(a, b))
> print(Levenshtein.distance(a, b))
> print(round(fuzz.ratio(a, b), 1))
> ```
>
> ```text Output theme={null}
> 2
> 3
> 89.7
> ```A similarity score measures how alike two strings are, not how likely the records are to describe the same person. A `fuzz.ratio` of 89.7 doesn't mean an 89.7% chance of a match.**Implementation:** compute a similarity score and set a threshold. A looser threshold catches more matches but adds false positives. See [Evaluating match quality](#evaluating-match-quality).### 11. Machine learning approachesWhen rules get too complex to maintain, a supervised model can learn from labeled examples and output a match score.**Example**- **Features:** name similarity score, email match (0/1), address similarity score, phone match (0/1)
- **Labels:** record pairs marked "Match" or "No Match" from prior knowledge
- **Model:** train a classifier, such as a random forest, then score new record pairs**Implementation**1) Extract features from record pairs.
2) Train the model on labeled pairs that represent the data you'll match in production.
3) Evaluate on a held-out set of labeled pairs the model didn't train on.
4) Tune the decision threshold to balance precision and recall.Most candidate pairs are non-matches, so labeled data is usually heavily imbalanced. A model that predicts "No Match" for everything can look accurate. Measure precision and recall instead of accuracy, and make sure your labeled set includes enough true matches and hard non-matches.> [!TIP]
>
> The techniques above make good features. Similarity scores from fuzzy and phonetic matching, plus exact-match flags from standardized fields, are often what the model learns from.***## Matching at scaleComparing every record in one dataset against every record in another gets expensive fast. Two datasets of one million records each produce one trillion possible pairs.**Blocking** reduces that search space. You assign each record one or more blocking keys, and compare only records that share a key. Common blocking keys include:- Normalized company domain
- Last name plus country
- A phonetic encoding of the name
- Company name plus locationIllustrative example: two datasets of 8 records each, split into 4 blocks of  records per dataset. Filled
squares are record pairs that get compared.In this example, blocking cuts 64 comparisons to 16. On real datasets, the reduction is usually far larger.Blocking has a trade-off. If two records that describe the same entity land in different blocks, you never compare them, and the match is lost. A typo in a last name is enough to cause it. To reduce that risk, combine several blocking keys and compare any pair that shares at least one.> [accordion] Example: generate candidate pairs with two blocking keys
>
> This example blocks on last name plus country, and separately on phone number. Dana Lee and Dana Leigh have different last names, so the first key misses them. The phone key catches them.
>
> ```python Generate candidate pairs theme={null}
> from collections import defaultdict
>
> crm = [
>     {"id": "crm-1", "name": "Robert Smith", "phone": "+14155550132", "country": "us"},
>     {"id": "crm-2", "name": "Dana Lee", "phone": "+12125550188", "country": "us"},
> ]
> vendor = [
>     {"id": "v-1", "name": "Bob Smith", "phone": "+14155550132", "country": "us"},
>     {"id": "v-2", "name": "Robert Smith", "phone": "+447700900123", "country": "gb"},
>     {"id": "v-3", "name": "Dana Leigh", "phone": "+12125550188", "country": "us"},
> ]
>
> # Each blocking key returns a value; records that share a value become candidates.
> blocking_keys = {
>     "last_name_country": lambda r: (r["name"].lower().split()[-1], r["country"]),
>     "phone": lambda r: r["phone"],
> }
>
> candidates = defaultdict(set)
> for key_name, key in blocking_keys.items():
>     index = defaultdict(list)
>     for v in vendor:
>         index[key(v)].append(v["id"])
>     for c in crm:
>         for v_id in index.get(key(c), []):
>             candidates[(c["id"], v_id)].add(key_name)
>
> for pair, keys in sorted(candidates.items()):
>     print(pair, sorted(keys))
> ```
>
> ```text Output theme={null}
> ('crm-1', 'v-1') ['last_name_country', 'phone']
> ('crm-2', 'v-3') ['phone']
> ```
>
> The code compares 2 candidate pairs instead of all 6. Robert Smith in `v-2` is never compared with `crm-1`, because the country and phone number both differ. Score the candidate pairs with the techniques above.***## Evaluating match qualityEvery matching pipeline makes two kinds of mistakes:- **False positives** link records that describe *different* entities.
- **False negatives** fail to link records that describe the *same* entity.Two metrics summarize them:- **Precision** is the share of accepted matches that are correct. False positives lower it.
- **Recall** is the share of all true matches that you found. False negatives lower it.A **match threshold** is the decision boundary between accepting and rejecting a match. Raising it improves precision and lowers recall. Lowering it does the opposite. The right balance depends on the cost of each mistake. A workflow that automatically merges CRM records should favor precision. A workflow that suggests candidates for manual review can favor recall.Move the threshold below to see the trade-off on ten labeled record pairs.

Threshold: 
        
        
        

Threshold presets



      

      

\<table><thead><tr><th scope="col">Record pair</th>
              \<th scope="col">Score</th>
              \<th scope="col">Known label</th>
              \<th scope="col">Decision</th>
              \<th scope="col">Outcome</th></tr></thead>
          \<tbody /></table>


      

Scores and labels are synthetic and illustrative. They aren't output from a specific algorithm or recommended production thresholds.

At a threshold of 0.90, every accepted match is correct, but you find only half of the true matches. At 0.70, you find five of six, but two of the seven accepted matches are wrong.Similarity scores aren't necessarily calibrated probabilities. A score of 0.9 from one method doesn't mean a 90% chance of a match, and it doesn't mean the same thing as 0.9 from a different method. Measure what each score means on your own data.### Validate your matching logic1) Assemble a representative sample of record pairs with known labels, including hard cases.
2) Run your matching logic on the sample, and measure precision and recall.
3) Look at the errors. Adjust thresholds and rules based on what you find.
4) Validate the adjusted logic on a separate labeled sample, so you don't tune to one set of examples.
5) Monitor results over time. Source data changes, and a threshold that worked last quarter may not work now.***## Entity resolution with PDL dataThe same techniques apply when you link your records to PDL data. Check exact field names and formats in the [Person Schema](https://docs.peopledatalabs.com/docs/fields) and [Company Schema](https://docs.peopledatalabs.com/docs/company-schema).### Match people across datasetsThe strongest signals are professional profile URLs and email addresses. Normalize LinkedIn URLs to PDL's format, which drops the protocol and `www.` (see [`linkedin_url`](https://docs.peopledatalabs.com/docs/fields#linkedin_url)). Without a strong identifier, combine name with employer, school, or location.- [Person Enrichment](https://docs.peopledatalabs.com/docs/person-enrichment-api) returns the single best match, with a likelihood score you can filter with `min_likelihood`.
- [Person Identify](https://docs.peopledatalabs.com/docs/person-identify-api) returns several scored candidates, so you can compare them yourself.### Match company recordsThe strongest signals are websites and company profile URLs. Normalize domains the way PDL does for [`website`](https://docs.peopledatalabs.com/docs/company-schema#website). Names are weaker signals.Check [`alternative_names`](https://docs.peopledatalabs.com/docs/company-schema#alternative_names) and [`alternative_domains`](https://docs.peopledatalabs.com/docs/company-schema#alternative_domains) for aliases and name changes. Use [`ultimate_parent`](https://docs.peopledatalabs.com/docs/company-schema#ultimate_parent) and [`all_subsidiaries`](https://docs.peopledatalabs.com/docs/company-schema#all_subsidiaries) when a subsidiary shares its parent's domain.### Maintain resolved entities over timeStore the PDL `id` next to your internal identifier, and send it back as `pdl_id` to the [Person](https://docs.peopledatalabs.com/docs/input-parameters-person-enrichment-api.md#pdl_id) or [Company](https://docs.peopledatalabs.com/docs/input-parameters-company-enrichment-api.md#pdl_id) Enrichment API instead of matching again. IDs can change between builds, so check the changelogs for merged or deleted IDs before you re-enrich. See [Persistent IDs](https://docs.peopledatalabs.com/docs/persistent-ids.md), the [Person Changelog](https://docs.peopledatalabs.com/docs/id-changelog.md), and the [Company Changelog](https://docs.peopledatalabs.com/docs/company-changelog).### Choose an implementation approach| Scenario | Suggested approach |
| :- | :- |
| Enrich an individual person or company record | [Person Enrichment](https://docs.peopledatalabs.com/docs/person-enrichment-api) or [Company Enrichment](https://docs.peopledatalabs.com/docs/company-enrichment-api) |
| Match internal records against a licensed PDL dataset | A custom pipeline using this guide's techniques. See [Data License](https://docs.peopledatalabs.com/docs/data-license.md). |
| Deduplicate records within an internal database | A custom pipeline using this guide's techniques |
| Maintain established links to PDL records | Stored PDL IDs, plus the [Person Changelog](https://docs.peopledatalabs.com/docs/id-changelog.md) and [Company Changelog](https://docs.peopledatalabs.com/docs/company-changelog) |***## Related resources> [card] [Person Schema](https://docs.peopledatalabs.com/docs/fields)
>
> Exact field names and values for person records.> [card] [Company Schema](https://docs.peopledatalabs.com/docs/company-schema)
>
> Exact field names and values for company records.> [card] [Persistent IDs](https://docs.peopledatalabs.com/docs/persistent-ids.md)
>
> How PDL person IDs persist from one build to the next.> [card] [Cleaner APIs](https://docs.peopledatalabs.com/docs/cleaner-apis)
>
> Standardize company, school, and location names to PDL's values.


## Related topics

- [Guides](https://docs.peopledatalabs.com/learn/guides.md)
- [Data Accuracy](https://docs.peopledatalabs.com/docs/data-accuracy.md)
- [November 2025 Release Notes](https://docs.peopledatalabs.com/changelog/november-2025-release-notes-v321.md)
- [November 2024 Release Notes](https://docs.peopledatalabs.com/changelog/november-2024-release-notes-v281.md)
- [PDLScores™ for Person Data](https://docs.peopledatalabs.com/docs/pdlscores-for-person-data.md)
