# Public Reference Finder — TruthFinder Alternative (`khadinakbar/truthfinder-alternative`) Actor

Find public-reference candidates for authorized name-and-location research. Export source URLs, collection times, and route outcomes in a privacy-scoped report for source review and follow-up research.

- **URL**: https://apify.com/khadinakbar/truthfinder-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Developer tools, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 completed public-source search reports

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Public Reference Finder — TruthFinder Alternative

Find public-reference candidates for authorized name-and-location research. Export source URLs, collection times, and route outcomes in a privacy-scoped report for source review and follow-up research. For authorized researchers, each dataset report provides a privacy-scoped public-reference result with sources and route status.

### Workflow: put the results to work

Choose an authorized research purpose and provide the name-and-location queries you can justify. Review each public reference at its source before drawing conclusions. This is a public-reference discovery step, not a criminal-record, background-check, or identity-verification service.

### Best fit

Choose this Actor when you need a transparent, source-linked starting point for your own information, a consented subject, or lawful public-interest research. Use it for public-reference discovery, then hands a small, reviewable dataset to the next authorized research step.

The Actor accepts only a broad name and optional city, region, or country. It returns candidate references from public Wikimedia indexes and preserves each source URL and collection time. A regulated verification workflow is the right next step for employment, housing, credit, insurance, eligibility, or law-enforcement decisions.

### TruthFinder alternative comparison

This is a workflow alternative for a narrow public-reference job, rather than a claim of full-suite replacement. TruthFinder is presented as a broader consumer people-search and report workflow; this Actor focuses on structured, source-linked collection and readback.

| Decision dimension | This Actor | TruthFinder workflow |
| --- | --- | --- |
| Scope and workflow | Bounded public-reference discovery through two public Wikimedia routes | Broader consumer people-search and report workflow |
| Billing and current cost | Pay per event for a persisted source report, plus platform usage; use the live Pricing tab for current cost | Current consumer pricing is outside this same-job comparison |
| Effective efficiency | One compact report per authorized query, with a small source cap and dataset readback | Same-workload usable-output timing has not been measured here |
| Input boundary | Requires authorized-use attestation, broad name, and optional broad location | Consumer people-search flow |
| Output and provenance | Source URL, collection time, route evidence, and terminal outcome per persisted report | Report-oriented consumer workflow |
| API and automation | Structured Apify API execution, dataset export, and key-value outcome readback | No TruthFinder API compatibility claim is made in this comparison |

This Actor is not affiliated with, associated with, or endorsed by TruthFinder. TruthFinder is a trademark of its owner.

### Use case workflow

A researcher starts with one consented name and a broad location. The Actor then checks the public Wikidata and Wikipedia reference routes sequentially, records the available source candidates, and writes one compact dataset row per completed query. Next, the researcher reviews the source URLs, confirms relevance independently, and passes only the necessary public reference into their authorized downstream process.

### Input

Set the authorized-use attestation, then submit one to three broad name-and-location queries. The location hint is a recall-preserving fallback qualifier: the Actor begins with the name alone and consults the name-plus-location variant only when both public routes return no candidate.

```json
{
  "queries": [
    {
      "fullName": "Ada Lovelace",
      "locationHint": "London, UK"
    }
  ],
  "authorizedUseConfirmed": true,
  "purpose": "self_lookup",
  "maxResultsPerQuery": 5,
  "responseFormat": "concise"
}
```

Purpose supports self lookup, consented research, and public-interest research. The smallest useful batch is one query; keeping batches small makes source review and cost readback straightforward.

### Output and outcome contract

Each completed query creates one dataset record. Raw name and location input stay in the request input and are represented in output only by a non-reversible query hash.

| Field | Meaning |
| --- | --- |
| queryHash | SHA-256 reference for the normalized query, without duplicating raw input |
| sourceResults | Bounded candidate references from Wikidata and Wikipedia |
| sourceUrl | Canonical public source URL for independent review and attribution |
| retrievedAt | UTC collection time for the report and each source candidate |
| sourceAttempts | Route-level availability, retry count, and query-variant evidence |
| safeUseNotice | Responsible-use boundary carried with each record |

```json
{
  "queryHash": "c7f7d9d3b15da3d5d21831d57c1a9f2d8ed5e058aa8c6d79bdf0d39912c58ef2",
  "retrievedAt": "ISO-8601 UTC timestamp",
  "purpose": "self_lookup",
  "responseFormat": "concise",
  "matchesFound": 2,
  "sourcesSucceeded": 2,
  "sourcesFailed": 0,
  "sourceResults": [
    {
      "source": "wikidata",
      "matchType": "knowledge_graph_entity",
      "title": "Ada Lovelace",
      "description": null,
      "sourceUrl": "https://www.wikidata.org/wiki/Q7259",
      "relevanceRank": 1,
      "retrievedAt": "ISO-8601 UTC timestamp"
    }
  ],
  "sourceAttempts": [
    {
      "source": "wikidata",
      "status": "SUCCEEDED",
      "attempts": 1,
      "matchesFound": 1,
      "queryVariant": "name_only"
    }
  ],
  "warnings": [],
  "safeUseNotice": "Use only for your own information, a consented subject, or lawful public-interest research.",
  "_note": "Candidate references require independent relevance review."
}
```

Read the OUTPUT key first. COMPLETE means every requested report persisted with both source routes available; PARTIAL preserves successful reports alongside route warnings; VALID\_EMPTY means the sources responded without a retained candidate. INVALID\_INPUT provides a safe correction message before any public-source request begins.

### Use the Apify API

```bash
curl -sS -X POST "https://api.apify.com/v2/acts/khadinakbar~truthfinder-alternative/runs?token=$APIFY_TOKEN" -H "content-type: application/json" -d '{"queries":[{"fullName":"Ada Lovelace","locationHint":"London, UK"}],"authorizedUseConfirmed":true,"purpose":"self_lookup","maxResultsPerQuery":5,"responseFormat":"concise"}'
```

After execution reaches a terminal status, retrieve the default dataset and the OUTPUT key. That readback separates a persisted public-source report from an invocation that only started.

### AI agent and MCP workflow

This regular Apify Actor can sit inside an AI agent or MCP-enabled workflow that is authorized to submit the stated input.

> Invoke TruthFinder Alternative for one authorized public-reference query. Read OUTPUT before the dataset. When the outcome is COMPLETE or PARTIAL, return only the candidate title, source URL, collection time, and scope notice; treat every candidate as a lead for independent review and report the billable report count.

For an agent, the reliable handoff is the terminal outcome first, then dataset readback, then source-URL provenance. Keep one query per decision when a human needs to evaluate relevance.

### Responsible use

Submit a query only with legal authority, the subject's consent where appropriate, and respect for applicable law and source terms. The output is designed for public-reference discovery and source review; high-impact screening belongs in a regulated process with documented governance.

TruthFinder is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by TruthFinder.

### Builder's note

I built this around a deliberately small output contract: two public reference routes, sequential polite requests, bounded retries, source URLs, and terminal key-value outcomes. In my implementation work, that made the result easier for a person or agent to read back, cite, and route into a review step without turning a broad people-search task into opaque data enrichment.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/truthfinder-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `source-search-completed` | Completed public-source search report | Charged once for each validated persisted public-source report after at least one required Wikimedia route responded. Apify platform usage is additional. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

## `queries` (type: `array`):

Provide one to three broad identity queries you are authorized to research, such as \[{"fullName":"Ada Lovelace","locationHint":"London, UK"}]. Each query accepts a name and an optional broad city, state, region, or country. The default contains one stable public-figure example and every completed query creates one billable source report. Do not submit an email address, phone number, street address, postal code, URL, birth date, or credential.

## `authorizedUseConfirmed` (type: `boolean`):

Set this to true only when you are searching your own information, a subject who has consented, or a lawful public-interest research subject. It defaults to false so unauthorized queries stop with a clear INVALID\_INPUT outcome. The Actor is never for employment, tenant, credit, insurance, law-enforcement, eligibility, or other FCRA-regulated decisions. This is an attestation, not identity verification.

## `purpose` (type: `string`):

State the allowed context for this source-search request: self\_lookup, consented\_research, or public\_interest\_research. It defaults to self\_lookup and is recorded in the result so downstream users can preserve the declared boundary. Choose consented\_research only with the subject's permission. This enum does not permit employment, housing, credit, insurance, or eligibility screening.

## `maxResultsPerQuery` (type: `integer`):

Cap the public source matches retained for each query after results are interleaved across Wikidata and Wikipedia. Choose a value from 1 to 10; the default is 5 for a compact, agent-readable report. Smaller values reduce response size while still checking both source routes. This is a result-display cap, not a promise that an identity match exists.

## `responseFormat` (type: `string`):

Choose concise for titles and source links only, or detailed to include short source-provided descriptions and search snippets. It defaults to concise to minimize personal-data exposure in the dataset. Both modes keep the same source URL, collection time, and outcome contract. This is not a request to fetch full article content or bypass a source access control.

## Actor input object example

```json
{
  "queries": [
    {
      "fullName": "Ada Lovelace",
      "locationHint": "London, UK"
    }
  ],
  "authorizedUseConfirmed": true,
  "purpose": "self_lookup",
  "maxResultsPerQuery": 5,
  "responseFormat": "concise"
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Default dataset with one privacy-scoped public-source report per completed query.

## `datasetItemsCsv` (type: `string`):

CSV export of the default dataset for authorized review or downstream workflows.

## `summary` (type: `string`):

Compact terminal totals without raw query values.

## `output` (type: `string`):

Outcome, query counts, source availability, matches, warnings, and charged event counts.

## `runSummary` (type: `string`):

Detailed safe diagnostics, source-route summaries, outcome, and cost-cap state.

## `consoleRun` (type: `string`):

Inspect logs, dataset records, terminal outcomes, and event charges.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        {
            "fullName": "Ada Lovelace",
            "locationHint": "London, UK"
        }
    ],
    "authorizedUseConfirmed": true,
    "purpose": "self_lookup",
    "maxResultsPerQuery": 5,
    "responseFormat": "concise"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/truthfinder-alternative").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": [{
            "fullName": "Ada Lovelace",
            "locationHint": "London, UK",
        }],
    "authorizedUseConfirmed": True,
    "purpose": "self_lookup",
    "maxResultsPerQuery": 5,
    "responseFormat": "concise",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/truthfinder-alternative").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    {
      "fullName": "Ada Lovelace",
      "locationHint": "London, UK"
    }
  ],
  "authorizedUseConfirmed": true,
  "purpose": "self_lookup",
  "maxResultsPerQuery": 5,
  "responseFormat": "concise"
}' |
apify call khadinakbar/truthfinder-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/truthfinder-alternative"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/O3iWJqjfyIt4VcKPX/builds/ql0NMiI4hmKmbgR4u/openapi.json