FaceCheck ID Face Search — Unofficial Reverse Face Lookup API

Search FaceCheck.ID by photo using this unofficial Apify actor. Upload a face image (base64 or URL) and get matched profiles from across the web — with source URLs, thumbnails, and confidence scores.

What is FaceCheck.ID?

FaceCheck.ID is a reverse face search engine that lets you find where a face appears online. It scans social media profiles, news articles, blogs, and public databases. This actor wraps FaceCheck.ID into a programmable API you can call from any workflow.

Disclaimer: This is an unofficial, community-built wrapper. It is not affiliated with, endorsed by, or connected to FaceCheck.ID.

What does this actor do?

This actor takes a face photo and searches FaceCheck.ID to find matching profiles and pages. It returns:

• Source URLs — where the face was found online
• Thumbnails — cropped face matches as base64 images
• Confidence scores — how closely each result matches (0–100)

Two search modes

Mode	Speed	What you get	Best for
Fast	~15–40s	Domain-level matches (e.g. instagram.com), confidence scores, thumbnails	Cheap screening — "does this face appear anywhere?"
Deep	~30–90s	Full source URLs (e.g. instagram.com/username), all matches, confidence scores, thumbnails	Investigations, OSINT, identity verification

Fast mode tells you where a face appears (which platforms/sites). Deep mode gives you the exact profile and page URLs.

How to use

Input

Provide either a base64-encoded image or a public image URL:

{
    "imageUrl": "https://example.com/photo.jpg",
    "mode": "deep"
}

Or with base64:

{
    "image": "/9j/4AAQSkZJRgABAQ...",
    "mode": "deep"
}

Output

Results are pushed to the default dataset:

{
    "success": true,
    "matches": [
        {
            "url": "https://instagram.com/username",
            "thumbnail": "/9j/4AAQSkZJRgABAQ...",
            "confidence": 92
        },
        {
            "url": "https://linkedin.com/in/username",
            "thumbnail": "/9j/4AAQSkZJRgABAQ...",
            "confidence": 85
        },
        {
            "url": "https://twitter.com/username",
            "thumbnail": "/9j/4AAQSkZJRgABAQ...",
            "confidence": 78
        }
    ],
    "total": 3
}

Error response

If something goes wrong, you get a clear error — no internal details exposed:

{
    "success": false,
    "message": "Verification failed, please retry"
}

Use cases

• OSINT investigations — find where a person's face appears online
• Identity verification — confirm someone is who they claim to be
• Catfish detection — check if a dating profile photo is stolen
• Brand monitoring — find unauthorized use of spokesperson photos
• Background checks — supplement traditional screening with face matching
• Journalism — identify individuals in photos for news stories
• Due diligence — verify identities for business partnerships

Image requirements

• Formats: JPEG, PNG, WebP
• Size: Max 10 MB
• Content: Must contain a clearly visible face
• Quality: Higher resolution = better results. Avoid blurry, dark, or heavily filtered photos.

Integration examples

Call via Apify API

curl -X POST "https://api.apify.com/v2/acts/d4rknode~facecheck-id-face-search/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"imageUrl": "https://example.com/photo.jpg", "mode": "deep"}'

Call from Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("d4rknode/facecheck-id-face-search").call(
    run_input={"imageUrl": "https://example.com/photo.jpg", "mode": "deep"}
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["success"]:
        for match in item["matches"]:
            print(f"{match['url']} — confidence: {match['confidence']}%")

Call from JavaScript / Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('d4rknode/facecheck-id-face-search').call({
    imageUrl: 'https://example.com/photo.jpg',
    mode: 'deep',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    if (item.success) {
        item.matches.forEach(m => console.log(`${m.url} — ${m.confidence}%`));
    }
});

Pricing

This actor uses a pay-per-event pricing model. You only pay when a search succeeds.

Tiers

Tier	Price per search	What you get
Fast	$0.02	Domain-level matches (e.g. instagram.com), confidence scores, thumbnails
Deep	$0.15	Full source URLs (e.g. instagram.com/username), all matches, confidence scores, thumbnails

Free trial

The first 3 searches are free so you can test the actor on your own images before paying. After the trial, searches are billed at the per-search price above.

How billing works

• You are charged per successful search via Apify's pay-per-event billing. Failed searches and errors are never charged.
• Fast ($0.02) runs an anonymous proxied lookup — it's cheap because it does not consume premium face-search credits.
• Deep ($0.15) runs a full premium lookup and returns exact source URLs.
• Both tiers also consume standard Apify platform credits for compute (RAM × time), typically $0.01–0.03 per run.

Why this is cheaper than FaceCheck.ID direct

Option	Cost per search	What you get
This actor (fast)	$0.02	API access, domain-level matches, automation-ready
This actor (deep)	$0.15	API access, full source URLs, all matches, automation-ready
FaceCheck.ID Rookie	$0.13/credit ($19 / 150)	Manual web interface, credits expire in 14 days
FaceCheck.ID Private Eye	$0.12/credit ($47 / 400)	Manual web interface, credits expire in 2 months
FaceCheck.ID Professional	$0.06/credit ($597 / 10,000)	Manual web interface, minimum $597 upfront

With this actor you get API access with no minimum spend, no expiring credits, and no manual work — plus a cheap fast tier for screening. Pay only for what you use.

Volume estimates (deep mode)

Searches/month	Deep cost	Equivalent FaceCheck.ID plan
50	$7.50	Rookie ($19) — you save $11.50
200	$30.00	Private Eye ($47) — you save $17
1,000	$150.00	Deep Investigator ($197) — you save $47
5,000	$750.00	Professional ($597) — API convenience premium

Screening at scale? Use fast mode at $0.02 to find which platforms a face appears on, then run deep only on the hits.

Platform compute costs depend on Apify pricing and are typically $0.01–0.03 per run on top of the per-search fee.

Limitations

• Results depend on FaceCheck.ID's database and matching algorithms
• Very low-resolution or heavily obscured faces may return no matches
• Searches run through a proxy and wait in FaceCheck's queue automatically; during very heavy load a search may hit the time limit and return a retryable error (you are not charged)
• This is an unofficial wrapper and may break if FaceCheck.ID changes their interface

FAQ

Q: Do I need a FaceCheck.ID account? No. The actor handles authentication internally.

Q: How accurate are the confidence scores? Scores range from 0–100. Matches above 70 are generally strong. Scores between 50–70 are possible but less certain.

Q: Can I search multiple images? Yes — use Apify's batch/scheduling features or call the API in a loop.

Q: What if the search returns no matches? The response will have "success": true with an empty "matches" array and "total": 0.

Q: Is my image stored? Images are processed in memory during the search and not persisted after the run completes.

Related tools

• FaceCheck.ID — the underlying search engine
• Apify — the platform this actor runs on
• PimEyes — another face search engine
• Google Reverse Image Search — general reverse image search

Changelog

• 1.0 — Initial release. Deep and fast search modes. Base64 and URL image input.