All resources
Security·6 min read·Replit·Sherlock·Maigret·ExifTool

Build Your Own OSINT Tools: Copy-Paste Replit Prompts

This is the set of build prompts from the video. You paste one into Replit in Free Mode and its agent builds the tool for real, no faked results. The first one is the photo metadata decoder you saw. The rest are a username finder, a profile grapher, a breach checker and a domain mapper.

Start here

You paste a prompt into Replit in Free Mode. Its agent builds the tool for real. Real data, live results, nothing faked. Then you test it and read the errors before you share it.

Use these on your own accounts, your own files and your own domains, or with permission. Every one of these reads public or self-supplied data, and it is still yours to run responsibly.

Open Replit and start building

Start a chat in Free Mode, then paste any prompt below in order.

Prompt 1: the photo metadata decoder

This is the one from the video. Upload a photo and it reads what is hidden inside the file. The camera, the lens, the capture time, and GPS coordinates plotted on a map. You can strip it or edit it too.

The real point is to run it on your own photos. See what they leak before you post them, strip it, and understand that any of these fields can be edited, so a location tag is never proof on its own.

Copy-paste this
Build a web app called PHOTO INTEL using the official ExifTool project to read and edit photo metadata. Inspect ExifTool's current documentation and output format before integrating it.

Accept only photos the user uploads themselves. Run a pinned ExifTool version in an isolated backend worker with strict file-size, file-type, execution-time and output limits. Do not execute uploaded content and do not fetch remote URLs.

Read the file and display only metadata the tool actually returns. Group it into device and lens, capture settings, timestamps, and location. When GPS tags exist, show the coordinates and plot them on a map. The map must use only the coordinates and must never upload the photo to the map provider. Explain that missing GPS does not mean an error, and that any of these fields can be edited.

Add an edit-and-clean mode that works on a copy of the file. Let the user change or remove individual fields, including GPS, then export the edited copy. Make clear in the interface that being able to edit metadata is exactly why metadata is not reliable evidence of where or when a photo was taken. Keep the original untouched and offer a fully stripped clean copy for safe sharing.

Use a near-black terminal interface with phosphor-green accents, readable monospace text and a layout that works on mobile and desktop. Never publish uploads, isolate each user's files, delete temporary files after processing, and add a Clear results action. No fabricated example metadata on the real result screen. Verify malformed files, unsupported formats, oversized uploads, a photo with no GPS, an edited re-export and deletion.

Prompt 2: the username finder

Type in one username and it checks hundreds of sites for an account with that name. Built on the real Sherlock project, so the searches are live and nothing is faked.

Copy-paste this
Build a fully working username-search web app called TRACE. Use the official sherlock-project/sherlock Python project on the backend. Inspect its current documentation and output format before integrating it. Do not create simulated scans, demo results or a recording mode.

Use a near-black hacker-terminal interface with phosphor-green accents, readable monospace text, fine borders and subtle animation. Make the layout excellent on mobile and desktop. The main input has a username placeholder and a working Search button.

Implement a Python backend and a React/TypeScript frontend. Execute Sherlock safely with argument arrays, never shell interpolation. Reject unsupported input and option-like usernames. Add bounded concurrency, per-user quotas, timeouts, cancellation and job cleanup. Pin the tested engine version.

Stream real search events through SSE or WebSockets. If the engine cannot provide a reliable total, use an indeterminate progress indicator. Never invent progress or turn blocked requests into not-found results. Distinguish possible match, not found, unable to check, canceled and failed.

Show platform, username, source URL and status. Add working filters, copy links, spreadsheet-safe CSV export and New search. Briefly explain that a matching username does not prove the account belongs to the same person. All target checks run server-side. Do not forward the visitor's IP in outbound headers. Keep logs minimal and isolate each user's jobs. Configure a deployment that supports the backend worker and streaming, then verify a real search, streaming, cancellation, errors, export and mobile layout.

Prompt 3: profile details and a connection graph

Run this after the username search works. It pulls the public details a profile already shows and draws the linked accounts as a graph. Built on Maigret and socid-extractor.

Copy-paste this
Extend the existing real username-search app with optional public-profile enrichment. Read the current soxoj/maigret and soxoj/socid-extractor documentation first. Choose a supported integration: direct socid-extractor parsing for supported profile pages, or a bounded Maigret search with enrichment. Explain which path you chose.

Add an Enrich selected profiles action. Show only fields actually extracted, such as display name, bio, avatar URL, account creation date, public statistics and explicitly published links. Keep unavailable fields empty. Store a source URL and retrieval time for every observation. Separate reported profile text from any inference.

Add a graph with Cytoscape.js. Use distinct relationship types for same username and explicitly linked profile. Clicking a node shows its evidence. Do not merge accounts into one confirmed person just because names or avatars match. Do not generate personality, sensitive-trait or location inferences.

Keep recursive expansion off until the user turns it on, then cap depth, requests and runtime. Use only approved public HTTP(S) destinations; block private, loopback, link-local and metadata addresses, including after DNS resolution and each redirect. Never fetch arbitrary file URLs, and apply the same checks to remote avatars. Stream real enrichment events into the terminal UI, keep the graph readable on mobile, and verify source attribution, blocked pages, missing fields, job ownership and cancellation.

Prompt 4: the breach checker

Check which known data breaches your own email or username shows up in, so you know exactly where to change a password. Built on the official Have I Been Pwned API.

Copy-paste this
Build a web app called BREACH CHECK that tells a user which known data breaches their own email or username appears in, using the official Have I Been Pwned API. Read its current API documentation, authentication and rate-limit rules first.

Require the user to confirm the address is their own, or one they are authorized to check, before any lookup. Store the API key only in server secrets and call the API server-side. Respect the rate limits with a queue and backoff.

For each result show the breach name, breach date, the data classes exposed and the short description, straight from the API with no embellishment. For password checking, use only the k-anonymity range endpoint so a full password or its hash never leaves the browser in the clear. Never store the addresses or passwords people check, and say so on screen.

Use a dark terminal interface, a clear empty state for no breaches found, CSV export and a Clear action. Explain that a listing means change that password and turn on two-factor, and that not being listed is not a guarantee. Verify a clean address, a breached address, rate-limit handling and errors.

Prompt 5: the domain footprint map

Map the public web assets of a domain you own or are allowed to check. Built on ProjectDiscovery's Subfinder, dnsx and httpx. This one is for your own property only.

Copy-paste this
Build a public web-asset inventory for authorized domains using projectdiscovery/subfinder, projectdiscovery/dnsx and projectdiscovery/httpx. Inspect current upstream documentation and use their supported structured outputs. Do not confuse ProjectDiscovery httpx with Python HTTPX.

Require an explicit domain allowlist and ownership verification, or an administrator-approved scope, before any active check. Collect passive subdomain candidates, resolve them, then run low-rate HTTP checks only on in-scope public destinations. Block private, loopback, link-local and cloud metadata destinations. Validate DNS answers and redirects, and stop rather than follow an out-of-scope redirect.

Show hostname, discovery source, DNS answers, observed status, page title, technology hints and last-checked time when available. Preserve unknown and blocked states. Do not label a host vulnerable from its title or fingerprint. No exploitation, brute force, port scans or login attempts.

Use a dark terminal dashboard with real animated events, searchable inventory, per-host details, CSV export and cancellation. Store provider keys only in server secrets. Add a queue, request budgets and per-domain concurrency limits. Verify the workflow against a domain you control, and ask for that domain if none is provided.

More tools you can spin up

Same idea, one plain sentence to the Replit agent and it builds the real thing. Tell it to inspect the upstream project or public API first, run checks server-side, and never fake a result.

  • A reverse image lookup that opens your photo in the search engines that support it.
  • A link unwrapper that follows a short link through every redirect and shows the final destination, server-side.
  • A website fingerprint that reports the public technology a site runs on.
  • A public records search over a free court API, like the lawsuit search build.
  • A GitHub footprint that collects what an account has published in the open, using the official GitHub API.

Swap in the data source you want. The build pattern is always the same: real source, honest states, your own data or permission.

The open-source projects behind these

Over 300,000 GitHub stars between them. These are the real engines your builds sit on.

Run it on yourself first

The fastest way to understand these is to point them at you.

  1. Decode your own photos and see what they carry. Strip the GPS before you post.
  2. Search the username you use the most, and open every match to see what is public.
  3. Run your email through the breach checker and change any password it flags.
  4. Clean up the old accounts you forgot you made.
  5. Stop reusing one username and one password everywhere.

Ground rules

  • Use these on your own accounts, files and domains, or with clear permission.
  • A matching username does not prove who owns an account, and metadata can be edited, so a GPS tag is not proof.
  • Respect every site's rules and rate limits, and keep checks running on the server, not through someone's home connection.
  • These read public or self-supplied data. They are not for surveilling, locating or harassing anyone.

Get the next one first

New prompts every week.

Free. The new drops and the tools behind them, before they hit the feed.

No spam · New issues Sunday · Unsubscribe anytime

Hire me for your business

Ready to invest in a custom build?

Implementation and custom builds start at $5,000 USD. Bring a specific business problem and an approved budget. Learning on your own? Keep exploring the free guides.

Frequently asked questions

No. Paste a prompt into Replit and its agent builds the tool. You still test the real searches and read the errors before you share your app.

The open-source projects are free under their own licenses. Hosting can cost money, and a few data sources (like the breach API) need a paid key. Basic Sherlock, Maigret and ExifTool builds do not need a paid search API.

Only if that photo still has GPS metadata, and most platforms strip it on upload. The real use is the reverse: check your own photos with the metadata decoder and strip the data before you post. And because metadata can be edited, a GPS tag is never proof on its own.

Checks that run on your app's backend use the server's connection, not yours. Opening a result link or loading its images uses your own browser. Ask the agent to confirm how your build handles it.

Reading public data and your own files is standard OSINT and digital-forensics work. Keep it to your own accounts, files and domains or ones you have permission for, respect each site's rules, and don't use it to target anyone. See the full OSINT platform guide for more.