# Reverse Face Search — Find Where a Face Appears Online (`muratcankuru/reverse-face-search`) Actor

Upload photo URLs and get back the public pages and social profiles those faces appear on, each with a 50-100 similarity score. Powered by the Trace API — no scraping, no CAPTCHA solving.

- **URL**: https://apify.com/muratcankuru/reverse-face-search.md
- **Developed by:** [Murat Can Kuru](https://apify.com/muratcankuru) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Reverse Face Search — find where a face appears online

Give this Actor one or more photo URLs. It returns the public pages and social profiles those faces appear on, each with a similarity score from 50 to 100.

It matches the **face**, not the file — so it finds the same person in a different photo, a different pose or a different year, which a reverse *image* search cannot do.

Built and maintained by the team behind [Trace](https://traceaifacescan.app/?utm_source=apify\&utm_medium=referral\&utm_campaign=actor).

### What it is useful for

- **Catfish and fake-profile checks.** Is this dating or marketplace profile using somebody else's photos?
- **Trust & safety.** Flag a new signup whose photo already belongs to another account.
- **Your own exposure.** Find where your face has been published, so you can ask for removals.

### What it is *not*

Not an identification service. It returns public URLs and similarity scores — **never names, addresses or personal records**. Twins, siblings, look-alikes, heavy filters and AI-generated portraits all score high. A match means *this face has been published here before*, which is enough to catch a stolen profile picture and not enough to accuse anybody of anything.

Using it to identify, locate, monitor, stalk or harass anyone is forbidden by the [terms](https://traceaifacescan.app/terms). Biometric processing is regulated in many places; that is your responsibility, not the Actor's.

### Before you start: get a Trace API key

This Actor runs searches on your own Trace account, so you need a key:

1. Sign up at [traceaifacescan.app](https://traceaifacescan.app/?utm_source=apify\&utm_medium=referral\&utm_campaign=actor).
2. Open **Panel → API** and create a key. It looks like `trk_live_…`.
3. Paste it into the Actor's **Trace API key** field. Apify stores it encrypted.

Searches are paid for in Trace credits — one credit per full search, bought in packs, no subscription, and credits do not expire. Apify itself only bills you for the compute this Actor uses, which is minimal: it spends its time waiting on the API, not working.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `apiKey` | string (secret) | — | Your Trace API key. Required. |
| `imageUrls` | array of URLs | — | Photos to search. One clear face each, at least 200×200 px, JPEG/PNG/WebP, under 8 MB. Required. |
| `revealLocked` | boolean | `false` | Without credits a scan returns a locked free preview. Leave this off and the Actor reports that instead of spending anything; turn it on to unlock automatically. |
| `minScore` | integer | `70` | Drop matches scoring below this. |
| `minTier` | enum | `possible` | Drop matches below this confidence tier. |
| `maxMatchesPerImage` | integer | `50` | Keep only the top N matches per photo. |
| `deleteScanAfterwards` | boolean | `true` | Delete the uploaded photo from Trace as soon as the results are read, instead of waiting for its expiry. |

Example:

```json
{
  "apiKey": "trk_live_…",
  "imageUrls": ["https://example.com/profile.jpg"],
  "minScore": 80,
  "minTier": "strong",
  "revealLocked": false,
  "deleteScanAfterwards": true
}
```

### Output

One dataset item per match:

```json
{
  "inputImageUrl": "https://example.com/profile.jpg",
  "scanId": "01K5T3ZQ8V6X2Y9N4M7P0R1S2T",
  "rank": 1,
  "score": 94,
  "tier": "near_certain",
  "platform": "instagram",
  "handle": "@real_owner",
  "url": "https://instagram.com/real_owner"
}
```

A `RUN_SUMMARY` key in the run's key-value store lists how many images were searched and why any of them failed.

#### Reading the score

| Score | Tier | Read it as |
|---|---|---|
| 50–69 | `weak` | Similar face. Could be anyone. |
| 70–79 | `possible` | Worth opening the link. |
| 80–89 | `strong` | Very likely the same person. |
| 90–100 | `near_certain` | Same person, or the same source photo. |

For automated flagging use `strong` and above. Below that you will bury your reviewers in false positives.

### How it works

No scraping, no CAPTCHA solving, no proxy rotation — so there is nothing here that quietly breaks when a third-party site changes its markup. The Actor downloads each image, calls the documented [Trace API](https://traceaifacescan.app/ai-face-scan-api/?utm_source=apify\&utm_medium=referral\&utm_campaign=actor), polls for the result and writes the matches to the dataset. Each upload carries the image's SHA-256 as an idempotency key, so a retry after a timeout never charges a second credit.

### Privacy

- With `deleteScanAfterwards` on (the default), the photo is deleted from Trace as soon as the results are read.
- No face is kept as a permanent biometric template for later lookup.
- Your API key is stored encrypted by Apify and is sent only to `traceaifacescan.app`.
- Do not upload photos of other people without a lawful reason for the check.

Full policy: [traceaifacescan.app/privacy](https://traceaifacescan.app/privacy)

### Errors you might see

| Message | What to do |
|---|---|
| `The Trace API key was rejected` | Check it in Panel → API. A revoked key and a mistyped one give the same answer on purpose. |
| `no credits, so the scan came back as a locked preview` | Top up, or set `revealLocked` to `true`. |
| `no_face_detected` | No usable face in that photo. Nothing was charged. |
| `not a supported image type` | Use JPEG, PNG or WebP. |
| `image is N MB; the limit is 8 MB` | Re-encode it smaller. |

### Also available

- [OpenAPI spec and Python / Node / curl examples on GitHub](https://github.com/muratcankuruoffical/reverse-face-search-api)
- [On RapidAPI](https://rapidapi.com/muratcankuruoffical/api/trace-reverse-face-search-api)
- [Browser version](https://traceaifacescan.app/?utm_source=apify\&utm_medium=referral\&utm_campaign=actor), no code needed

# Actor input Schema

## `apiKey` (type: `string`):

Your Trace API key (trk\_live\_…). Create one for free at traceaifacescan.app → Panel → API. Apify stores it encrypted, and it is sent only to traceaifacescan.app. Searches are paid for with your own Trace credits.

## `imageUrls` (type: `array`):

Photos to search. One clearly visible face each, at least 200×200 px, JPEG, PNG or WebP, under 8 MB. One credit is spent per photo.

## `revealLocked` (type: `boolean`):

Without credits a scan returns a free, locked preview: you learn that the face was found, not where. Leave this off and the Actor reports the locked scan instead of spending anything.

## `minTier` (type: `string`):

Drop matches below this tier. For automated fake-profile flagging use 'strong' or higher — anything lower will bury your reviewers in false positives.

## `minScore` (type: `integer`):

Drop matches scoring below this. The API never returns anything under 50.

## `maxMatchesPerImage` (type: `integer`):

Keep only the highest-scoring N matches for each photo.

## `deleteScanAfterwards` (type: `boolean`):

On by default. The results are already in the dataset, so there is no reason to leave the photo on the server until its expiry date.

## Actor input object example

```json
{
  "imageUrls": [
    "https://example.com/profile.jpg"
  ],
  "revealLocked": false,
  "minTier": "possible",
  "minScore": 70,
  "maxMatchesPerImage": 50,
  "deleteScanAfterwards": true
}
```

# Actor output Schema

## `matches` (type: `string`):

Every match kept after the score and confidence filters, one dataset item each, with platform, handle, URL and score.

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

How many photos were searched and why any of them failed.

# 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 = {
    "imageUrls": [
        "https://example.com/profile.jpg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("muratcankuru/reverse-face-search").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 = { "imageUrls": ["https://example.com/profile.jpg"] }

# Run the Actor and wait for it to finish
run = client.actor("muratcankuru/reverse-face-search").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 '{
  "imageUrls": [
    "https://example.com/profile.jpg"
  ]
}' |
apify call muratcankuru/reverse-face-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muratcankuru/reverse-face-search"
        }
    }
}
```

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/8YtIC6HYJWQAN7DbK/builds/qTS4dFwBxNt8NQLDI/openapi.json