November 15, 2026
OSINT from Scratch. Part 1: Search Intelligence, Indexing & Google Dorking
A Note from the Author

By solvnox
15 min read
A Note from the Author
I've already covered quite a few areas of OSINT on this channel, from individual tools and investigation techniques to more specialized topics. The thing is, most of those articles were standalone pieces rather than parts of a bigger series. One day we'd be looking at satellite imagery, the next we'd be digging into gaming accounts, and then we'd jump to something completely different.
So I've decided to start a separate series alongside my usual posts. This time, we'll go through OSINT step by step, starting with the fundamentals and gradually working our way toward more advanced techniques and practical investigations.
That doesn't mean my previous articles are suddenly outdated, or that this channel is turning into nothing but tutorials. I'll keep publishing the usual breakdowns of tools and specific OSINT topics. This series will simply give us a more structured path, with each new part building on what we've covered before.
Introduction
OSINT (Open Source Intelligence) is the process of finding, collecting, verifying, and analyzing information from publicly accessible sources, without gaining unauthorized access to private systems.
These sources can include social media, public profiles, search engines, documentation, government records, technical databases, and pretty much any other information that's openly available.
In practice, an OSINT investigation often starts with very little to work with.
Maybe all you've got is a username, the name of a Telegram channel, a profile link, or some random digital identifier. Even that can be enough to start uncovering related posts, other public accounts, mentions on third-party websites, and traces of someone's online activity.
But here's something worth keeping in mind: finding a few matching usernames doesn't automatically mean those accounts belong to the same person.
Different people can use identical usernames. Posts get copied and reposted across websites. And sometimes the information you're looking for simply isn't indexed by search engines.
That's why proper OSINT isn't just about knowing which search queries to type into Google. You also need to understand how search engines discover information, how their indexes work, and why certain pages never show up in search results.
In this article, we'll break down how Google Search works, how indexing happens, and how to use search operators and combine them effectively.
For practical examples, I'll be using my own username, solvnox, and my Telegram project, solvnox_project.
How Does Google Work, and What Exactly Is a Search Index?
A lot of people imagine Google as some kind of system that scans the entire internet every time you enter a search query.
That's not really how it works.
Google doesn't revisit every webpage whenever someone searches for something. Instead, it relies on its own search index, which contains information about pages and documents that its systems have already discovered and processed.
We can roughly divide Google Search into three main stages:
- Crawling โ discovering and retrieving webpages.
- Indexing โ processing and organizing the information found.
- Serving search results โ selecting and displaying results for a particular query.
This distinction matters a lot in OSINT.
A webpage existing on the internet and that same webpage appearing in Google are two completely different things.
Crawling โ How Google Discovers Pages
Google uses automated crawlers, including Googlebot, to discover information across the web.
These crawlers follow accessible links, discover new URLs, check sitemap files, and retrieve webpage content through HTTP requests.
Let's say a website publishes an article mentioning solvnox_project.
Google might discover that article through links within the website itself or through links from other websites.
But just because the page exists doesn't mean Google will necessarily crawl it.
Some websites restrict access to search crawlers. Others load their content dynamically. And some URLs simply haven't been discovered yet.
Crawling can also be influenced by a file called robots.txt, usually located in the root directory of a website.
For example:
User-agent: *
Disallow: /private/User-agent: *
Disallow: /private/This configuration tells crawlers that follow these rules not to crawl the /private/ directory.
But there's an important catch.
A robots.txt file isn't a security feature.
If a page is publicly accessible without authentication, blocking crawlers from visiting it doesn't magically make that page private.
Rendering โ Processing Page Content
After retrieving a page's HTML, Google may execute JavaScript to process and analyze the resulting content.
This is especially relevant for modern web applications, social platforms, and online directories.
For example, a website might initially return an almost empty HTML document, with the actual content appearing only after JavaScript runs in the browser.
Google can process many pages like this, but that doesn't mean every dynamically loaded element will necessarily be indexed.
If information only appears after logging in, performing a specific user action, or calling an API that Google's crawlers can't access, it may never make it into the search index.
Indexing โ Organizing the Information
Once Google has processed a page, it analyzes its content, extracts text, links, titles, and other information, and decides whether that document should be added to its search index.
One useful concept here is the inverted index.
In a normal document, you have a collection of words.
An inverted index works the other way around: it maps words to lists of documents where those words appear.
That's a simplified explanation, of course, but it helps illustrate why search engines can retrieve documents containing particular terms so quickly.
Google also takes duplicate content into account and may select one canonical version of a page.
For example, if the same article is available at several different URLs, Google won't necessarily show every copy in its search results.
Website owners can also prevent indexing by using the following directive:
<meta name="robots" content="noindex"><meta name="robots" content="noindex">If Googlebot retrieves the page and encounters an applicable noindex directive, Google should remove that page from its search index.
However, if the crawler can't access the page in the first place, for example because crawling is blocked, it may never see that directive.
Further reading: Google's official documentation on crawling and indexing
Why Doesn't Google Show Every Result?
Imagine you know that a particular username is being used across several online platforms, but Google only returns two or three results.
There are several possible explanations.
One platform might allow public profiles to be indexed, while another blocks search crawlers. A third might generate its content through a dynamic interface.
The page might also be undiscovered, excluded from Google's index, or grouped together with another version of the same document.
And that's before we even get into query processing and ranking.
Google doesn't simply check whether a page contains the exact characters you typed. It also tries to figure out which results are most relevant, potentially taking related words, spelling corrections, and other signals into account.
This is where the site: operator becomes particularly useful.
For example:
site:github.com "solvnox"site:github.com "solvnox"This restricts your search to the specified domain.
But if Google returns nothing, it doesn't necessarily mean there are no mentions of solvnox anywhere on GitHub.
Another thing worth remembering: the approximate number of results shown for a site: query isn't an accurate count of how many pages Google has indexed from that website.
Search results are not the same thing as a complete inventory of Google's index.
Google Dorking
Google Dorking is a technique that uses advanced search operators and combinations of those operators to find specific information.
These operators let you narrow results down to particular domains, search for exact phrases, exclude unwanted websites, target document formats, and work with date ranges.
But don't get the wrong idea.
Google Dorking doesn't somehow give you access to information Google can't retrieve. It works within the capabilities and limitations of Google's search index and search engine.
To use it properly, you need to understand not just what individual operators do, but how they behave when combined.
Let's say we want to find public mentions of the username solvnox outside Telegram.
We could start with:
"solvnox""solvnox"And then exclude a particular source:
"solvnox" -site:t.me"solvnox" -site:t.meThe second query looks for matches on websites outside the t.me domain.
There's no guarantee it'll return anything useful, but it changes the scope of the search without changing the identifier we're investigating.
Searching for a Username
Let's start with a basic search:
solvnoxsolvnoxAt this stage, Google may interpret the query on its own and consider different types of matches.
Now let's add quotation marks:
"solvnox""solvnox"Quotation marks are used to search for an exact word or phrase.
They're particularly useful when looking up usernames, since we're usually interested in a specific identifier rather than words that happen to look similar.
Next, let's try the project name:
"solvnox_project""solvnox_project"It's worth remembering that solvnox and solvnox_project are two different search identifiers.
One might appear in personal profiles, while the other could show up in Telegram channel directories, articles, or links to the project.
If we want to cover both, we can try the OR operator:
"solvnox" OR "solvnox_project""solvnox" OR "solvnox_project"This tells Google to look for results matching either condition.
There's a catch, though.
Google doesn't guarantee that complicated logical expressions will be handled as strictly as they would be in a dedicated Boolean search system.
So if you're doing a systematic investigation, it's still worth running separate searches for each identifier.
Restricting Searches to Specific Websites
The site: operator lets you restrict your search to a particular website, domain, or URL prefix.
For example, to look for mentions of solvnox on GitHub:
site:github.com "solvnox"site:github.com "solvnox"For Telegram:
site:t.me "solvnox"site:t.me "solvnox"For Reddit:
site:reddit.com "solvnox"site:reddit.com "solvnox"And for Steam:
site:steamcommunity.com "solvnox"site:steamcommunity.com "solvnox"These queries can help you investigate specific platforms, but they don't automatically confirm that a matching account exists or belongs to the person you're investigating.
Say Google returns a GitHub repository containing the word solvnox.
That match could come from a user profile, a README file, a project description, or just something another developer happened to write.
You need to open the result and check exactly where the identifier appears.
Also, site: won't give you a complete list of every page on a website.
If Google can't find a username on a particular platform, try the platform's own search engine.
For example, GitHub has separate search functionality for users, repositories, and source code:
GitHub Search and Google work differently, so don't be surprised when they return different results.
Combining Search Operators
Now let's make things a little more interesting.
Suppose we want to find public mentions of solvnox specifically in an OSINT context.
We could start with:
"solvnox" "OSINT""solvnox" "OSINT"This looks for pages containing both expressions.
If we want to exclude Telegram:
"solvnox" "OSINT" -site:t.me"solvnox" "OSINT" -site:t.meNow we're looking for mentions of the username alongside the term OSINT, while filtering out results from Telegram itself.
We can also search for mentions of a specific project:
"solvnox" "Gansar""solvnox" "Gansar"Or a particular field:
"solvnox" "Osint""solvnox" "Osint"The idea is pretty straightforward: we're looking for publicly available material where a given username appears alongside another relevant term.
But there's an important distinction between a topical match and confirmed authorship.
Just because a page contains both solvnox and OSINTdoesn't mean the person using that username wrote everything on the page.
A website might host articles from multiple authors or automatically aggregate content from various sources.
Context matters.
Grouping Search Conditions
The OR operator can also be used when you're looking for alternative values.
For example:
"solvnox" ("OSINT" OR "SOCMINT")"solvnox" ("OSINT" OR "SOCMINT")This query is intended to find material related to either of those two fields.
You can also try combining platform restrictions:
"solvnox" (site:github.com OR site:gitlab.com)"solvnox" (site:github.com OR site:gitlab.com)But these combinations are worth testing separately.
If you get no results, split the query into two:
site:github.com "solvnox"
site:gitlab.com "solvnox"site:github.com "solvnox"
site:gitlab.com "solvnox"That makes it much easier to figure out which condition is affecting the results.
And that's exactly why a complicated dork isn't necessarily better than a simple search query.
The point isn't to cram as many operators as possible into one search. It's to make sure every restriction serves a purpose.
Excluding Sources You've Already Checked
Once you've found a few public mentions, another problem starts showing up: the same websites keep appearing in your search results.
Let's say we already know the project's official Telegram channel:
To look for mentions elsewhere, we can use:
"solvnox_project" -site:t.me"solvnox_project" -site:t.meIf another website keeps appearing and you've already examined its content, you can exclude it with an additional -site: condition.
Just don't start excluding websites before you've actually found and checked them.
Filtering out dozens of domains in advance is an easy way to miss potentially useful information.
And if your query becomes too restrictive, Google may simply return an empty results page.
When that happens, remove some of the restrictions and try alternative spellings of your identifier.
Searching for Alternative Spellings
Usernames and project names aren't always written consistently.
For example, besides:
"solvnox_project""solvnox_project"We can also try:
"solvnox project""solvnox project"Or:
"solvnox-project""solvnox-project"That doesn't mean all these variations are officially used by the project.
We're simply checking whether other people might have written the name differently.
This is especially useful when researching Russian-speaking online communities, where Telegram channel names are often mentioned without preserving the exact characters used in the original username.
Search engines can also handle underscores, hyphens, and other special characters differently.
So if searching for solvnox_project doesn't get you anywhere, try searching for the project name without the underscore.
Of course, if you find a page with a similar name, you'll still need to verify that it's actually related to the original channel.
Searching with intitle: and inurl:
Two other operators you'll come across in Google Dorking are intitle: and inurl:.
The first is used to search for words in page titles.
For example:
intitle:solvnoxintitle:solvnoxThe second focuses on URLs:
inurl:solvnoxinurl:solvnoxThis can help uncover pages whose addresses contain a particular identifier.
For example:
site:github.com inurl:solvnoxsite:github.com inurl:solvnoxHowever, these operators aren't part of the main set described in Google's current user-facing documentation, so their behavior may be less predictable.
If a query isn't working as expected, it makes sense to fall back to documented operators like site: and exact phrase searches.
And remember: finding a username in a URL doesn't prove that the page belongs to the person using that username.
The URL might refer to a repository, an article, somebody else's profile, or an entirely different object.
Searching by Date
If you're investigating the history of a public project, date restrictions can help narrow things down.
For example:
"solvnox_project" after:2025-01-01 before:2026-01-01"solvnox_project" after:2025-01-01 before:2026-01-01This query is intended to find material Google associates with that time period.
For a different range:
"solvnox_project" after:2026-01-01 before:2026-11-01"solvnox_project" after:2026-01-01 before:2026-11-01
But there's something you need to watch out for.
Dates shown in Google Search don't always match the original publication dates.
A third-party website might update an old page mentioning a Telegram channel, even though the actual content was published much earlier.
Google may associate that page with its update date or other time-related signals.
So if you're trying to reconstruct a timeline, don't rely solely on the date displayed in search results.
Open the original sources and check their timestamps directly.
Searching for Documents
Sometimes usernames and project names appear not just on webpages, but inside PDFs, presentations, and other documents.
To search for specific file formats, we can use the filetype: operator.
For example:
"solvnox" filetype:pdf"solvnox" filetype:pdfOr:
"solvnox_project" filetype:pdf"solvnox_project" filetype:pdfThese queries are meant to check whether Google has indexed any documents containing those identifiers.
I'm not claiming such PDF files actually exist in this case. These are simply search queries we can test.
If you've got no reason to believe the information you're after was published in a PDF, there's no need to restrict your search to that format.
Also keep in mind that Google might not fully index the contents of certain documents, especially older scans where the text is actually embedded as an image.
Testing Search Queries in Practice
Let's use my username, solvnox, and see what we can find on GitHub.
We'll start with:
site:github.com "solvnox"site:github.com "solvnox"
Google returns no results, even though I have public projects on GitHub.
Now let's remove the domain restriction:
solvnox githubsolvnox github
This time, Google displays an AI Overview mentioning some of my tools, including GrangerBrowser and Pamp.
Why the difference?
The site: operator restricts the search to a specific domain, while a regular query gives Google more freedom to use information from other websites.
The AI Overview is also generated separately from the standard list of search results and may draw on multiple sources.
So just because a tool appears in Google's AI Overview doesn't mean its GitHub repository has necessarily been indexed.
To check that, you need to open the cited sources and see where Google actually got the information.
GitHub Code Search โ Finding Information in Source Code
When conducting an OSINT investigation, useful information isn't limited to social media profiles or Google results.
Sometimes the interesting stuff is sitting right inside public GitHub repositories.
Developers occasionally leave references to their other projects, Telegram channels, documentation, old domains, and various identifiers in their source code.
Those details can help uncover additional connections.
GitHub has a dedicated tool for searching repository contents:
https://github.com/search?type=code
Let's start by searching for mentions of my Telegram channel:
"solvnox_project""solvnox_project"GitHub will search for that exact expression within publicly accessible code included in its search index.
We can also search for the full link:
"t.me/solvnox_project""t.me/solvnox_project"This might uncover files where someone referenced the channel, whether in a README, configuration file, or application source code.
Searching Within a Specific Repository
If we're interested in one particular project, we can narrow the search using repo:.
For example:
repo:watsoncore/Granger-OSINT "solvnox"repo:watsoncore/Granger-OSINT "solvnox"This tells GitHub to search for solvnox only within the specified repository.
We can also restrict searches to a particular organization or user.
For example:
org:github "security"org:github "security"To search within a specific programming language, use language:.
"telegram" language:python"telegram" language:pythonAnd to search specific file paths, use path:.
"solvnox" path:README.md"solvnox" path:README.mdWhy Is This Useful in an Investigation?
Imagine you've found a public GitHub profile that appears to be connected to the project you're investigating.
Using Code Search, you can check whether the project's name appears in other repositories, what links are associated with it, and whether there are references to older names or domains.
If you find a match, open the original file and examine the surrounding code or text.
From there, you can check the commit history to see when that particular reference was added.
But here's the part people sometimes overlook.
A username or link appearing in somebody else's repository doesn't automatically establish a connection between the account owners.
Someone might have copied the code, quoted the documentation, or simply mentioned the project.
GitHub Code Search also isn't a complete archive of everything ever uploaded to GitHub.
Some files may be missing from its search index, and a normal code search doesn't search through every historical commit.
So if a search comes back empty, that doesn't prove the information never existed.
To investigate older versions of a file, you'll need to examine the repository's history separately.
Finding Usernames with OSINT Tools
Google doesn't always find public profiles, even when those profiles exist and can be accessed directly.
That's why it's worth using dedicated username-search tools alongside regular search engines.
These tools check whether a particular username appears to be registered on different platforms.
Hands-On: WhatsMyName vs. Maigret
Let's take my username, solvnox, and run it through two different tools to see what comes back.
The first is WhatsMyName:
After entering the username, the service performed 653 checks and returned just one result: a YouTube channel using the handle @solvnox.
Here's the funny part.
That YouTube channel isn't mine.
At the same time, WhatsMyName failed to detect my public Telegram, GitHub, and other social media profiles.
Now let's try the same username with Maigret:
https://github.com/soxoj/maigret
We'll run:
maigret solvnox --htmlmaigret solvnox --htmlIn my case, Maigret returned 12 accounts and extracted additional information from four profiles.
The results included Telegram, GitHub, TikTok, and several other platforms.
And unlike WhatsMyName, it didn't just return profile links.
For example, from GitHub, it retrieved the account creation date, numeric user ID, display name, number of public repositories, and the city listed in the profile.
From TikTok, it extracted the profile description, numeric account ID, and account statistics.
Of course, some of those results still need to be verified.
For example, the YouTube channel using the same username doesn't belong to me.
And just because someone lists a particular city in their profile doesn't mean that's where they actually live.
So we ran the exact same username through WhatsMyName and Maigret, yet got completely different results.
That's largely because the tools support different platforms, use different methods to check account availability, and have different capabilities when it comes to extracting public information.
The takeaway is simple:
Don't rely on a single tool when investigating usernames.
And don't assume every account it finds belongs to the same person.
Check profile content, look for direct cross-links between accounts, and verify the connections before drawing conclusions.
Conclusion
In this first part, we've covered how Google discovers and indexes webpages, why some information never appears in search results, and how Google Dorking can help narrow down investigations.
We've also explored a few additional tools.
Using WhatsMyName and Maigret, we tested username searches and saw just how different the results can be, even when both tools are given the exact same input.
We also looked at GitHub Code Search and how it can be used to find project references and other identifiers inside public source code.
One thing I really want to emphasize is that a lack of search results doesn't mean the information you're looking for doesn't exist.
Every search engine and OSINT tool has its own limitations, supported sources, and ways of processing data.
At the same time, finding a match isn't proof of anything on its own.
Different people can use the same username. Project links can appear in somebody else's posts. And public information can easily be copied, taken out of context, or misinterpreted.
That's why going back to the original source and checking the evidence is so important.
In the next part, we'll move on to SOCMINT and take a closer look at social media investigations, including persistent account identifiers, public profile history, and how to verify connections between different accounts.
More resources and materials are available in my private archive:
https://t.me/+MZg6SsDl60pjNmFi
There's a discount running until November 6, so don't miss it.
For access inquiries: @solvnox
Our Telegram channel: @solvnox_project
MM: Zakhar Alexey (@solvnox)