Most teams working with professional data have no written standard for how they handle it. The data arrives, it gets stored, it gets used, and nobody has decided what happens when someone asks to be removed or what the retention period is or who is allowed to query it.
That is usually fine right up until it is not: a deletion request arrives, an enterprise buyer sends a security questionnaire, a regulator registers a complaint, or an employee exports the whole database to a spreadsheet on their way out.
This covers the practices worth having in place regardless of jurisdiction, written as engineering and operations rather than law. It is not legal advice and I am not a lawyer. Where it touches regulation it is describing published requirements, and anything specific to your situation belongs with counsel.
Start with purpose, not with data
The question that prevents most problems: what are you going to do with this record?
Almost every bad practice in this category traces back to collecting first and deciding later. If you cannot name the specific use before you resolve a record, you are accumulating liability rather than building an asset.
A workable standard:
Write down the purpose per use case. "Routing inbound demo requests to the right sales region." "Confirming a candidate's current employer before outreach." Specific enough that someone could tell whether a given query serves it.
Resolve only records that serve a stated purpose. This also saves money, since most databases contain a long tail nobody will ever query, and resolving it is cost with no return either way.
Do not reuse data across purposes without checking. Data collected to route a support ticket is not automatically available for an outbound campaign. Whether that matters legally varies; whether it matters to your enterprise buyers does not vary at all.
This is the same discipline that makes enrichment cost-effective, which is why the practice in profile lookup best practices starts the same way. Good governance and good economics point in the same direction here.
Collect less than you can
Data minimisation is the single most useful principle in this whole area, and it is routinely ignored because APIs return everything by default.
A profile record can contain a person's full employment history, education, skills, certifications, languages, publications, follower counts and location. If your use case is routing an inbound lead by company size, you need company size. Storing the other thirty fields because they arrived in the payload is a choice, and it is one you will have to defend.
Store the fields your stated purpose needs. Not the fields the API returned.
Be especially careful with anything inferable about protected characteristics. Names, photographs, languages, education institutions and locations can all be used to infer ethnicity, nationality, age or religion. You may have no intention of doing so, but if those fields feed an automated scoring model, the model can learn the inference whether you intended it or not. If you score accounts or candidates automatically, audit what your model is actually weighting.
Treat full employment history as sensitive. Career gaps carry information about health, caring responsibilities and redundancy. There is rarely a business reason to retain a complete history when the current role is what you act on.
A practical rule: if you would be uncomfortable showing a person their own record in your system, you are storing too much.
Retention: decide it, write it, enforce it
Most organisations have no retention period for enrichment data, which means the answer is "forever," which is almost never defensible.
Three things to put in place:
A default retention period per purpose. Lead records that never converted do not need to persist for years. Candidate records in recruiting legitimately persist longer, because a candidate who was not right in 2023 may be right in 2026, and that is a reasonable purpose if you have stated it.
Automatic expiry, not manual cleanup. A retention policy nobody enforces is a document rather than a control. Expiry should run on a schedule without anyone remembering.
A shorter clock for records that never served their purpose. A lead that was resolved, routed and never touched again is a record you are holding with no justification. Those should age out faster than records in active use.
Tie this to your refresh strategy rather than running them separately. If a record is not worth refreshing, it is usually not worth keeping, and the field-level model for deciding that is in CRM data decay.
Honour opt-outs properly
This is the practice with the clearest technical implementation and the one most often done badly.
When a provider tells you an individual has opted out of resolution, that is a permanent state, not a transient failure. The API surfaces it as a permission error rather than a not-found, and it is not charged.
Build the suppression list on first occurrence.
1from renidly import Renidly, PermissionDeniedError, RenidlyError
2
3renidly = Renidly() # reads RENIDLY_API_KEY from the environment
4
5def resolve(identifier: str):
6 if is_suppressed(identifier):
7 return None # never ask again
8
9 try:
10 return renidly.data.people.retrieve(id=identifier)
11 except PermissionDeniedError:
12 suppress_permanently(identifier) # durable, survives every future run
13 return None
14 except RenidlyError as e:
15 log.warning("lookup failed", code=e.error_code)
16 return NoneIf your stack is Node, the same pattern with the suppression check before the call rather than after:
1import { Renidly, PermissionDeniedError, RenidlyError } from "renidly";
2
3const renidly = new Renidly();
4
5export async function resolve(identifier: string) {
6 if (await isSuppressed(identifier)) return null;
7
8 try {
9 return await renidly.data.people.retrieve({ id: identifier });
10 } catch (e) {
11 if (e instanceof PermissionDeniedError) {
12 await suppressPermanently(identifier);
13 return null;
14 }
15 if (e instanceof RenidlyError) return null;
16 throw e;
17 }
18}Three details that matter.
Check before you call, not just after. Otherwise every batch run re-requests the same suppressed records forever. It costs nothing in credits but it is the wrong posture, and it means your logs show you repeatedly asking about someone who said no.
Make suppression durable and global. Not per-job, not per-table. If the suppression list lives in a worker's memory or a single pipeline's state, the next pipeline will not know.
Propagate to what you already stored. An opt-out that only stops future lookups while leaving the existing record in your CRM is half a measure. Decide what happens to data already held, and build the path to act on it.
Handle inbound deletion requests
Separately from provider-level opt-outs, people may contact you directly. You need a path for that, and it needs to work.
One intake route, documented. An address or form that reaches a real process rather than a shared inbox nobody owns.
A way to find every copy. This is the part that fails. Enrichment data spreads: the CRM, the warehouse, a BI extract, a marketing tool, an old CSV in someone's drive. If you cannot enumerate where a record lives, you cannot honour a deletion request, and that enumeration is an architecture problem you solve in advance rather than under a deadline.
A record of what you did. Which identifiers, when, and the outcome.
That last point is becoming a formal requirement rather than good practice in some jurisdictions. California's Delete Act created a centralised platform, DROP, which opened to consumers on 1 January 2026; from 1 August 2026 registered data brokers must access it at least every 45 days, process the deletion requests it contains, and report a status for each one of record deleted, record opted out of sale, record exempt, or record not found. Penalties for failing to act run to $200 per request per day.
Whether your business is a registered data broker under that definition is a question for your counsel, and the definition is narrower than "any company holding data." But the direction is clear across jurisdictions: centralised, auditable deletion with reporting obligations. Architecture that can enumerate and delete every copy of a record is going to be table stakes.
Keep provenance
If you cannot say where a field came from, you cannot answer a question about it. That applies to a regulator, to an enterprise buyer's security review, and to a colleague asking why the CRM says someone works somewhere they left.
Three pieces of metadata on every enriched field:
| Field | Why |
|---|---|
| Source | Which provider or process produced it |
| Confidence | How certain the match was |
| Verified at | When it was last confirmed |
This is the same provenance layer that makes refresh prioritisation possible, so it earns its cost twice. Most databases do not provide it for custom fields, so it usually means companion columns or a parallel table.
Also log writes. Old value, new value, source, confidence, timestamp. When someone disputes a record, a log is an answer and a shrug is not.
Control who can query
An enrichment API key is a capability to look up people. Treat it like one.
Never put the key in client-side code. The SDK reads RENIDLY_API_KEY from the environment precisely so it stays server-side. A key in a bundle is a key someone else is spending, and a lookup capability you have handed to the internet.
Never return enriched records to the browser. If a user-facing endpoint sends the resolved record back to the client, anyone can submit arbitrary identifiers through your form and read data about people who never interacted with your product. You have built a public lookup service and you are paying for it.
1# Wrong: the browser now holds a person's record
2return {"account_id": account_id, "enrichment": result.person}
3
4# Right: the browser gets a decision
5return {"account_id": account_id, "next": "sales_handoff"}Use separate keys per environment and per tenant. If you serve multiple customers, per-request key overrides mean one client cannot query on another's behalf:
1person = renidly.data.people.retrieve(
2 id="prsn_06d0d44dogo2m",
3 options={"api_key": tenant_key},
4)Log who queried what. Internal misuse is a real risk and it is invisible without logging. An audit trail of which user or service resolved which records is both a deterrent and the only way to investigate afterwards.
Rotate keys and scope access. Not every engineer needs production credentials.
Do not let automated data make consequential decisions alone
The practice that matters most where the stakes are highest.
Professional data drives decisions about people: whether to contact them, how to prioritise them, sometimes whether to consider them for a role. The higher the stakes, the less weight automated data should carry on its own.
Keep a human in the loop for anything consequential. Routing a lead to a sales region is low stakes. Filtering a candidate out of a recruiting pipeline is not, and in some jurisdictions automated decisions with significant effects carry specific obligations.
Never act on low-confidence data. A graded confidence value exists so you can treat certainty differently from a guess. A low match belongs in a review queue, never in an automated action.
Give people a way to correct the record. If your product displays enriched data about someone to themselves, let them fix it. If a prospect tells a rep their title is wrong, that correction should reach the database and survive the next refresh.
That last one is also a data quality practice. A human who spoke to the person last week knows more than any dataset, which is why write rules should require high confidence before overwriting a human-entered value. The gate is in profile lookup best practices.
Accuracy is part of responsibility
Worth saying plainly, because it gets treated as a separate concern from compliance and it is not.
Holding wrong data about someone and acting on it causes real harm: outreach to a role they left, a scoring model that mis-sorts them, a recruiter contacting them about a job that does not fit anything they do now. Several regulatory frameworks include accuracy as an obligation rather than a nicety.
The practices that improve accuracy are the ones from the operational side of this work:
Verify what you act on. Resolution tells you who someone is. Verification tells you whether an address works. Employment confirmation tells you whether the role is current. They are three separate checks and the one you skip is the one that embarrasses you.
Detect change rather than assuming stability. A record is correct as of when it was resolved. Watching for movement events means stale records surface as a signal rather than as a surprise, and the pattern is in job change signals.
Treat absence of a signal carefully. "No change detected" is not the same as "nothing changed." Every provider has detection lag, and overstating what your data proves is its own kind of inaccuracy.
What to require from any vendor
Whoever you buy from, including us, there is a list worth running before you sign. Every item here is something an enterprise buyer will eventually ask you for, so having the answers also makes you easier to buy from.
A DPA you can actually sign, with subprocessors listed.
Documented deletion behaviour. What happens when you delete a record on your side, and what happens to data you have already pulled if the contract ends.
Opt-out propagation. How individual opt-outs are surfaced to you through the API, and what you are expected to do with them.
Provenance you can pass on. Enough to answer your own customer's security questionnaire, since their questions become your questions.
Regional handling. Where processing happens, and whether that fits your obligations.
An honest failure model. A provider that returns a confident guess rather than an explicit not-found leaves you unable to tell a fact from an inference, which makes every downstream decision less defensible.
The broader evaluation method, including how to test accuracy rather than trusting claims, is in how to evaluate a B2B data provider.
A note on our own position: this post deliberately describes general standards rather than making claims about Renidly's regulatory status, because a vendor's own compliance posture is something you should verify in writing rather than read on their blog. Ask us the same questions you would ask anyone, and put the answers in the contract.
A practical checklist
Work down this list. Most teams can complete the top half in a week.
Before you resolve anything
- Each use case has a written purpose
- You collect only the fields that purpose needs
- Records outside a stated purpose are not resolved
Storage
- Every enriched field carries source, confidence and verified-at
- Enriched values are separable from human-entered ones
- You can enumerate every place a record is stored
- Writes are logged with old and new values
Rights
- Provider opt-outs build a durable, global suppression list
- Suppression is checked before each lookup, not only after
- There is one documented intake route for deletion requests
- A deletion request can be executed across every copy
- Deletions are recorded with outcome and date
Retention
- A retention period exists per purpose, in writing
- Expiry runs automatically
- Records that never served their purpose age out faster
Access
- No API key in client-side code
- No enriched records returned to the browser
- Separate keys per environment and tenant
- Query access is logged and scoped
Decisions
- Low-confidence data never triggers automated action
- Consequential decisions keep a human in the loop
- People can correct records about themselves
- Corrections survive the next refresh
Five things not to do
Do not resolve your entire database because you can. Cost with no return, liability with no purpose.
Do not keep everything the API returns. Store what your purpose needs. The rest is exposure you chose.
Do not treat an opt-out as a retry-able error. It is permanent. Suppress and move on.
Do not let an automated score alone decide something consequential about a person. Particularly in recruiting.
Do not claim a compliance posture you have not verified. This applies to vendors describing themselves and to you describing your product. An unverified claim in a sales deck becomes a contractual representation, and that is a much worse problem than not having made the claim.
Frequently asked questions
Is it legal to look up professional profiles?
Working with business contact information is routine and lawful in most jurisdictions under appropriate conditions, but the conditions differ by region and by what you do with the data. The practical answer is that purpose, minimisation, retention and honouring individual rights are what determine whether a given use is defensible, and specifics belong with counsel.
What is data minimisation?
Collecting and keeping only the data your stated purpose actually requires, rather than everything available. It reduces both risk and cost.
How long should I keep enrichment data?
Long enough to serve the purpose you stated and no longer. Set the period per purpose, enforce expiry automatically, and age out records that never served their purpose faster than those in active use.
What do I do when someone opts out?
Build a durable suppression list on first occurrence, check it before every lookup rather than only catching the error afterwards, and decide what happens to data you already hold.
What is the California DROP?
A centralised deletion platform created under California's Delete Act. It opened to consumers on 1 January 2026, and from 1 August 2026 registered data brokers must access it at least every 45 days, process the requests, and report a status for each. Whether a given business meets the data broker definition is a legal question.
Should enrichment data drive automated decisions?
For low-stakes routing, generally yes. For anything consequential about a person, keep a human in the loop and never act on low-confidence matches.
What should I ask a data vendor?
For a signable DPA with subprocessors listed, documented deletion behaviour including contract termination, how opt-outs are surfaced, what provenance you can pass to your own customers, where processing happens, and whether their API returns explicit not-founds rather than confident guesses.
The one-line version
Decide the purpose before you resolve anything, because almost every problem in this area starts with collecting first and justifying later. Store the fields that purpose needs rather than everything the payload contained. Set a retention period and enforce it automatically rather than by memory.
Treat opt-outs as permanent and check your suppression list before each lookup rather than only catching the error. Build the ability to find and delete every copy of a record before you need it, not during a deadline. Keep provenance on every field so you can answer where something came from, at what confidence, and when it was checked.
And keep a human between automated data and any decision that materially affects a person, particularly in recruiting, where the cost of a confident wrong answer falls on someone who never agreed to be in your database.
Most of this is also just good engineering. The practices that keep you defensible are the same ones that keep your data accurate and your costs down, which is the useful thing about this area: there is rarely a trade-off between doing it properly and doing it well.
If you want to see what a resolution actually returns before deciding what to keep, the free tools will resolve a single record with no signup. For a procurement conversation, a DPA, or the answers to any of the vendor questions above, talk to us directly.


