# seekr puts OSINT tools, a target database and a notebook in one app

> Seekr is a Go and TypeScript OSINT workbench with a web interface on localhost, a BadgerDB database of targets, and adapters that bring existing tools such as phoneinfoga and subfinder into the same workflow. It is explicitly beta software, it needs no API keys for any feature, and its release line last moved in 2023 even though the repository still receives pushes.

**seekr-osint/seekr** — A multi-purpose OSINT toolkit with a neat web-interface.

- Repository: https://github.com/seekr-osint/seekr
- Stars: 887 · Forks: 85
- Language: Go
- License: GPL-3.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/seekr-osint-seekr

## The pitch is a workbench, not a tool

Seekr is a multi-purpose toolkit for gathering and managing OSINT data with a sleek web interface. The introduction says the desktop view enables you to have all of your favourite OSINT tools integrated in one, with a backend written in Go and BadgerDB as the database, offering a wide range of features for data collection, organization and analysis.

The section headed Why use seekr over my current tool answers the obvious question directly. Seekr combines note taking and OSINT in one application, and it can be used alongside your current tools. The design goal is stated as being designed with OSINT in mind and optimized for real world use cases.

That framing matters for the feature list, because almost every entry is about organisation rather than collection. There is a database for OSINT targets, account cards for each person in the database, account discovery integrated with the account cards, and predefined commonly used fields in the database. There is a guide feature where you enter information you have and get web tools recommended to help you. There is a GitHub to email feature.

The headline claim is that no API keys are required for all features, which is a meaningful design constraint in a field where most tools ask you to sign up for provider keys before they will do anything.

The audience is a researcher, an investigator, or as the README puts it, just someone looking to gather information. The licence is GPL-3.0, the primary language is Go, the default branch is main, and the last push to the repository was on 2026-06-16.

## The dependency list names the tools it wraps

The go.mod is the most informative document in the repository, because it names the OSINT capabilities directly.

The adapters and integrations include subfinder for subdomain discovery, phoneinfoga for phone number reconnaissance, google-search for search, wayback-machine-golang for the Internet Archive's Wayback Machine, and likexian/whois for whois lookups. There is go-git for GitHub repository access, which is what the GitHub to email feature would be built on, and rocketlaunchr/google-search for the search side.

The scraping and parsing stack is PuerkitoBio/goquery and gocolly/colly, with the src-d/enry library for detecting the language of a repository, and nyaruka/phonenumbers for working with phone numbers. The web layer is gin with the CORS middleware, the command line uses acmd and promptui, and the data is stored with dgraph-io/badger/v4.

Two of those deserve a comment. The Wayback Machine integration means the tool can look at how a web page looked in the past, which matters for investigations where the current content has been changed or removed. And enry, the language detector, is there because a GitHub repository has to be classified before the GitHub to email feature can do anything sensible with it.

The one dependency to note is the .NET flavour of a different project, tkrajina/typescriptify-golang-structs, which generates TypeScript type definitions from Go structs. That is the mechanism behind the shared types between the Go backend and the TypeScript front end, and the repository has a newtypes/ directory alongside it.

## Four install routes, and the web interface is always on port 8569

The installation section offers a binary, Docker, a Nix flake and a source build, and the last of those is the one that explains the repository layout.

The source build is the same on Windows and Linux, and it needs Go and TypeScript installed:

```sh
git clone https://github.com/seekr-osint/seekr
cd seekr
go generate ./...
tsc --project web
go run main.go
```

Three commands do the work. go generate produces the generated code, the TypeScript compiler builds the web front end, and go run starts the server.

Docker is the shortest route, and it pulls a prebuilt image:

```sh
docker pull ghcr.io/seekr-osint/seekr:latest
docker run -p 8569:8569 ghcr.io/seekr-osint/seekr:latest
```

and on NixOS the project supports nix flakes:

```sh
nix shell github:seekr-osint/seekr
seekr
```

Whichever route you take, the interface is a browser at localhost on port 8569, on the /web/ path, and the README is explicit that unstable builds may contain bugs and are not recommended for production use. The Windows and Linux stable builds are distributed as executables and binaries from the releases page, and the Docker image is tagged latest, which is the unstable line rather than a pinned release.

The port is not incidental, because the Dockerfile exposes it and starts the binary on it.

## The container builds the TypeScript front end inside a Go image

The Dockerfile is short and shows how the two languages fit together.

The build stage is golang:1.20-alpine3.16. It copies the source in, runs go mod download, installs nodejs and npm with apk, installs TypeScript globally with npm, then runs go generate ./... and tsc --project web with the watch flag set to false, and finally builds the binary with go build. The runtime stage is alpine:3.18, with only the seekr binary copied across, the port exposed, and the entrypoint as the command:

```bash
EXPOSE 8569

CMD ["/bin/seekr","--ip","0.0.0.0","--port","8569"]
```

The bind address is worth noting, because it is the difference between a tool that only listens on the loopback interface and one that listens on every interface of the machine. The default in the container is 0.0.0.0, so if you run the Docker image on a server without a firewall, the OSINT database and the interface behind it are reachable from the network. The README's own instructions run the image with the port published to the host, so the exposure is a decision the operator makes rather than a default the tool prevents.

The final image is deliberately minimal. The Go binary is statically linked in the build stage and the runtime layer carries no shell tooling, so the container is small and the attack surface is a web server and whatever the OSINT adapters reach out to.

The repository root has the other pieces of the release pipeline: a .goreleaser.yaml for building the binaries, a release.sh script, an update-hash.sh script, a Dockerfile, a default.nix and flake.nix with a flake.lock for the Nix route, and an AppRun file, which is the AppImage entry point that the Linux builds use.

## Plugins, an API and the wiki as the real documentation

The README is a short front page and the actual documentation lives elsewhere, which is the normal arrangement for a project of this size.

It says to check the wiki for the setup guide and the API documentation, and the repository root has an API.md file alongside the api/ directory that presumably holds the implementation. The web/ directory holds the front end, and the README's opening line describes it as a neat web-interface with a desktop view.

Plugins are a first class concept. The feature list ends with Themes and Plugins, the repository has a seekrplugin/ directory, and there is an examples/plugins/ directory. That combination tells you the design intent, that a user can extend the toolkit with their own collection logic and their own look, and that a plugin author has a directory to work in and an example to copy from.

The web front end is TypeScript, and the two thanks lists at the bottom of the README point at that: WinBox.js for windowing, FileSaver.js for saving files from the browser, and a Discord integration written in Go. The Discord one is interesting because it is a Go project rather than a JavaScript library, which suggests some of the tool's output is pushed into a chat channel rather than only read in the browser.

For an evaluator, the two questions worth answering before committing are how a plugin is written and what a plugin is allowed to do, and the wiki and the seekrplugin/ directory are where those answers are.

## Beta software, a 2023 release line, and an explicit legal framing

The README is unusually direct about its own maturity, and an adopter should take it at its word.

There is a warning block stating that Seekr is a beta software and still in an early stage of development, and the installation section repeats the point with a quick warning that unstable builds may contain bugs and are not recommended for production use.

The release history matches that framing. The recent releases are 0.4.0 with the subtitle Odyssey on 2023-08-23, 0.3.9 on 2023-08-11 and 0.3.8 on 2023-08-04, so the tagged releases stopped more than three years ago. The repository, however, is not archived and the last push was on 2026-06-16, so work has continued on the default branch without new tags. If you are evaluating this, that is the important detail: the Docker image tagged latest, and the source build, are both newer than the last release, and neither is described as stable.

The legal framing is equally explicit. The tool is intended for legitimate and lawful use only, is provided for educational and research purposes, and should not be used for illegal or malicious activities, including doxxing. The disclaimer defines doxxing as the practice of researching and broadcasting private or identifying information about an individual without their consent, notes that it can be illegal, and says the creators and contributors will not be held responsible for misuse. By using the tool you agree to use it only for lawful purposes and to comply with all applicable laws and regulations, and the disclaimer says misuse may result in criminal and civil prosecution.

That is a stronger statement than most projects make, and it is a useful one for an organisation that has to approve this kind of software, because it tells you the maintainers have thought about the use case boundaries rather than leaving them implicit. The contact address for legal questions is a proton mail address.

The licence is GPL-3.0, with the LICENSE file at the repository root and a CODE_OF_CONDUCT.md and CONTRIBUTING.md alongside it.

## Conclusion

Adopt seekr if you are a researcher or investigator who wants OSINT tools, a database of targets and a place to write findings in one place, and if you are willing to run beta software with an offline first workflow. Do not adopt it as a production system, because the README calls it beta and still at an early stage of development, warns that unstable builds may contain bugs, and the newest tagged release is 0.4.0 from 2023-08-23. Before you rely on it, read the legal disclaimer in full, since the tool is for lawful research and the project is explicit that it must not be used for doxxing, and check the data storage decisions, because everything you gather lands in a local BadgerDB database on the machine running the tool.

## FAQ

### What is the seekr OSINT toolkit?

It is a multi-purpose toolkit for gathering and managing OSINT data with a web interface, whose backend is written in Go with BadgerDB as the database. The README says it combines note taking and OSINT in one application and is designed for real world use cases.

### Does seekr need API keys?

No. The key features list states that no API keys are required for all features, which is a deliberate design choice for a tool that integrates other people's OSINT tools such as phoneinfoga.

### How do I run seekr with Docker?

Pull the image ghcr.io/seekr-osint/seekr:latest and run it with docker run -p 8569:8569 ghcr.io/seekr-osint/seekr:latest, then open the web interface on localhost:8569/web/. The image starts the binary with --ip 0.0.0.0 --port 8569.

### Can I build seekr from source?

Yes, with Go and TypeScript installed. Clone the repository, then run go generate ./..., tsc --project web and go run main.go. The Docker build does the same three steps inside the image.

### Is seekr safe to deploy for production use?

The README warns that seekr is beta software still at an early stage of development, and that unstable builds may contain bugs and are not recommended for production use. The last tagged release was 0.4.0 on 2023-08-23, and the tool is for legitimate and lawful use only, not for doxxing.

## Sources

- [Issues](https://github.com/seekr-osint/seekr/issues)
- [License: GPL-3.0](https://github.com/seekr-osint/seekr/blob/main/LICENSE)
- [README](https://github.com/seekr-osint/seekr/blob/main/README.md)
- [Releases](https://github.com/seekr-osint/seekr/releases)
- [seekr-osint/seekr on GitHub](https://github.com/seekr-osint/seekr)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/seekr-osint-seekr