Cover image for Build a Website Tech Stack Scanner CLI in Go Using Wappalyzergo

ToolSura

A terminal scanner tells you what powers a website without opening a browser. For developers, security engineers, and automation builders, detecting a stack straight from the command line beats reading headers by hand or digging through HTML. A lightweight CLI does the whole job.

This guide builds a fast website technology scanner in Go using ProjectDiscovery's open-source library. If you're new to detection, read our detecting website technologies using Go guide first.

External resources:

What we are building

By the end of this tutorial you'll have a CLI that:

  • accepts a target URL
  • fetches the HTTP response
  • detects technologies
  • prints results in the terminal

That's the same approach recon pipelines and developer tooling use as a foundation.

Why build a CLI scanner?

CLI tools are fast, scriptable, and drop into automation without the repetitive manual checks. Common uses:

  • security reconnaissance
  • attack surface discovery
  • competitive research
  • automation pipelines
  • developer diagnostics

For the concepts behind detection, our technology fingerprinting explained for developers article goes deeper.

Step 1: Create the project

Start by creating a new directory:

mkdir tech-scanner-cli
cd tech-scanner-cli

Enter fullscreen mode Exit fullscreen mode

Initialize a Go module:

go mod init tech-scanner-cli

Enter fullscreen mode Exit fullscreen mode

Step 2: Install Wappalyzergo

Run:

go get github.com/projectdiscovery/wappalyzergo

Enter fullscreen mode Exit fullscreen mode

This pulls in the fingerprinting engine ProjectDiscovery maintains.

Step 3: Write the CLI tool

Create a main.go file and add the following code:

package main

import (
    "flag"
    "fmt"
    "io"
    "log"
    "net/http"

    wappalyzer "github.com/projectdiscovery/wappalyzergo"
)

var target = flag.String("url", "", "Target URL to scan")

func main() {
    flag.Parse()

    if *target == "" {
        log.Fatal("Please provide a URL using -url")
    }

    resp, err := http.Get(*target)
    if err != nil {
        log.Fatalf("failed to fetch target: %v", err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalf("failed to read response: %v", err)
    }

    client, err := wappalyzer.New()
    if err != nil {
        log.Fatalf("failed to create client: %v", err)
    }

    technologies := client.Fingerprint(resp.Header, body)

    fmt.Println("Detected technologies:")
    for tech := range technologies {
        fmt.Println("-", tech)
    }
}

Enter fullscreen mode Exit fullscreen mode

Step 4: Build the CLI

Compile the binary:

go build

Enter fullscreen mode Exit fullscreen mode

That drops an executable into your project directory.

Step 5: Run the scanner 

./tech-scanner-cli -url https://example.com

Enter fullscreen mode Exit fullscreen mode

Expected output:

Detected technologies:
- Cloudflare
- React
- Nginx

Enter fullscreen mode Exit fullscreen mode

That's a working detector in under 50 lines of Go.

Optional: Install it globally

To run the tool from anywhere:

sudo cp tech-scanner-cli /usr/local/bin/

Enter fullscreen mode Exit fullscreen mode

Then:

tech-scanner-cli -url https://example.com

Enter fullscreen mode Exit fullscreen mode

Improve the CLI (recommended enhancements)

Once the basic scanner works, add:

Output formats

  • JSON for automation
  • CSV for reporting

Concurrency

Scan multiple targets at once.

Timeout controls

Stop slow sites from blocking scans.

Category detection

Use FingerprintWithCats to group technologies.

Using custom fingerprints

Wappalyzergo ships an embedded dataset, but you can load your own if you need to:

client, err := wappalyzer.NewFromFile("fingerprints.json", true, true)

Enter fullscreen mode Exit fullscreen mode

That covers internal tooling or specialized detection without writing a matcher yourself.

When should you use a CLI scanner?

A terminal scanner earns its place when you're:

  • running reconnaissance at scale
  • automating security workflows
  • integrating into CI pipelines
  • building developer utilities

For a tooling comparison, watch for our Wappalyzergo vs Wappalyzer guide.

Conclusion

You now have a fast, scriptable website technology scanner built entirely in Go.

ProjectDiscovery's open-source libraries let developers wire reliable detection into their workflows without rebuilding the engine. If this guide was useful, the repository is worth a look:

Next, detecting website technologies using Go explains the fingerprinting process behind the scanner.

This article was originally published on ToolSura. For more on technology detection, read How Technology Detection Works and Technology Fingerprinting for Developers.