Scope people sourcing with source-backed identity review

Quick answer

A people-sourcing pilot should record professional role and organization claims with their source URLs and observation times, then hold unresolved identities for human review. Agree the permitted purpose, sources, retention, and correction process first. The sample is synthetic and does not identify real people or provide contact data.

{
    "profile_url": "https://example.com/profiles/ava-lane",
    "role": "Synthetic Data Platform Lead",
    "organization": "Example Harbor Labs",
    "observed_at": "2026-09-17T00:00:00Z",
    "evidence_url": "https://example.com/profiles/ava-lane",
    "match_status": "accepted"
}

Fit a professional sourcing workflow

Use this outline for recruiting operations or a sourcing-tool builder with a defined role brief and permitted public sources. It describes professional evidence about a possible person. It does not describe job listings, personal contact discovery, candidate ranking, suitability scoring, or hiring recommendations.

The sample uses fictional names on reserved example domains. It cannot verify that a person exists, that a profile is current, or that a record meets a hiring criterion. An accepted row means only that the agreed evidence checks passed for the next human review.

Agree the permitted-use boundary

Before any pilot, write down the purpose, allowed source list, required fields, geography, access roles, retention period, correction route, and deletion process. Include only the personal data needed for that purpose. Public visibility alone does not establish consent or authorize every reuse.

Where the EU General Data Protection Regulation applies, Article 5 includes principles for specified purposes, accuracy, and storage limitation. Applicability depends on the processing context. Agree legal basis and responsibilities with qualified counsel for the relevant jurisdictions.

Do not infer sensitive traits or add private email addresses and phone numbers to this proposed record. Keep requests and examples free of real candidate information.

Define the identity review rules

If the profile and evidence page differ, retain both URLs. A role found on a job listing does not establish the profile holder's current role. Resolve duplicates using a documented rule; do not merge people based on name similarity alone.

Validate the synthetic JSON

Download the synthetic JSON sample or CSV sample, and use the pilot brief to prepare implementation questions. Save the JSON as sample.json, then save the code below as validate-sample.py beside it. Run the local check with Python 3.12.0; Windows instructions are not included. Install Python from the official downloads page. The Python JSON documentation describes file parsing.

python3 --version
python3 validate-sample.py

The validator checks required fields, allowed synthetic hosts, timestamps, identity status, and a review reason. It reads the sample locally and does not contact a source. The validator sends malformed URLs and values of the wrong type to review rather than treating them as accepted. It still checks only this synthetic record contract; it does not verify a live source or make a service request.

import json
from datetime import datetime
from pathlib import Path
from urllib.parse import urlsplit

SAMPLE_PATH = Path("sample.json")
ALLOWED_HOSTS = {"example.com", "example.org"}


def is_synthetic_https_url(value):
    if not isinstance(value, str):
        return False
    try:
        parsed_url = urlsplit(value)
        hostname = parsed_url.hostname
        parsed_url.port
        username = parsed_url.username
        password = parsed_url.password
    except ValueError:
        return False
    return (parsed_url.scheme == "https"
            and hostname in ALLOWED_HOSTS
            and username is None
            and password is None)
ALLOWED_STATUSES = {"accepted", "review", "unknown"}
REQUIRED_FIELDS = {
    "profile_url",
    "role",
    "organization",
    "observed_at",
    "evidence_url",
    "match_status",
}

sample = json.loads(SAMPLE_PATH.read_text(encoding="utf-8"))
if sample.get("sample_type") != "synthetic":
    raise ValueError("Expected a synthetic schema example")

records = sample.get("records")
if not isinstance(records, list) or not records:
    raise ValueError("Expected at least one record")

for index, record in enumerate(records, start=1):
    issues = []
    if not isinstance(record, dict):
        print(f"record {index}: review; row is not an object")
        continue

    missing = sorted(REQUIRED_FIELDS - record.keys())
    if missing:
        issues.append("missing " + ", ".join(missing))

    for field in ("role", "organization"):
        value = record.get(field)
        if value is not None and (not isinstance(value, str) or not value.strip()):
            issues.append(f"{field} must be non-empty text or null")

    for field in ("profile_url", "evidence_url"):
        value = record.get(field)
        if not isinstance(value, str):
            issues.append(f"{field} must be text")
            continue
        if not is_synthetic_https_url(value):
            issues.append(f"{field} is outside the synthetic HTTPS hosts")

    observed_at = record.get("observed_at")
    try:
        if not isinstance(observed_at, str):
            raise ValueError
        timestamp = datetime.fromisoformat(observed_at.replace("Z", "+00:00"))
        if timestamp.tzinfo is None or timestamp.utcoffset() is None:
            issues.append("observed_at needs a timezone")
    except ValueError:
        issues.append("observed_at is not a timezone-aware ISO timestamp")

    status = record.get("match_status")
    if not isinstance(status, str) or status not in ALLOWED_STATUSES:
        issues.append("match_status is invalid")
    elif status != "accepted" and not record.get("review_reason"):
        issues.append("non-accepted row needs review_reason")

    outcome = "accepted" if status == "accepted" and not issues else "review"
    print(f"record {index}: {outcome}")
    for issue in issues:
        print(f"  reason: {issue}")

Expected output:

record 1: accepted
record 2: review

The second record is held because its match status is review. A local pass verifies only schema conditions. It does not establish identity, accuracy, consent, lawful use, employment status, or candidate suitability. The official datetime documentation explains aware timestamps, and URL parsing documentation notes that parsing does not validate a URL.

Keep the human review boundary

Review source evidence and identity matches before a recruiter acts. Record corrections and deletion requests against a defined owner and retention rule. Do not interpret a row marked accepted as permission to contact, a consent signal, or a hiring decision.

Use the workflow email draft addressed to hello@proxylane.dev to discuss the role brief, permitted sources, intended use, fields, geography, volume, retention, correction route, and acceptance rules. The draft is not sent automatically. Feasibility, scope, price, and acceptance criteria require human confirmation before any work or purchase terms are agreed.

ProxyLaneTraffic never expires

Premium residential proxies
From $2/GB

Run this workflow with the tools you already use. Rotating or sticky sessions up to 72 hours.

Try 350 MB for $1.95 View plans Discuss managed data