>5B subdomains. curl, done.

# pip install requests
import os, time, requests

def search(apex, token=None):
    headers = {"Accept-Encoding": "gzip"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
    for _ in range(2):
        r = requests.get(
            "https://api.sub.md/v1/search",
            params={"apex": apex},
            headers=headers,
            timeout=10,
        )
        if r.status_code == 429:
            time.sleep(int(r.headers.get("Retry-After", 2)))
            continue
        r.raise_for_status()
        return r.text.splitlines()
    raise RuntimeError("rate-limited twice")

if __name__ == "__main__":
    import sys
    print("\n".join(search(sys.argv[1], os.getenv("SUBMD_TOKEN"))))

package main

import (
    "bufio"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "strconv"
    "time"
)

func search(apex, token string) ([]string, error) {
    u := "https://api.sub.md/v1/search?apex=" + url.QueryEscape(apex)
    client := &http.Client{Timeout: 10 * time.Second}
    for i := 0; i < 2; i++ {
        req, _ := http.NewRequest("GET", u, nil)
        req.Header.Set("Accept-Encoding", "gzip")
        if token != "" {
            req.Header.Set("Authorization", "Bearer "+token)
        }
        resp, err := client.Do(req)
        if err != nil {
            return nil, err
        }
        defer resp.Body.Close()
        if resp.StatusCode == 429 {
            d, _ := strconv.Atoi(resp.Header.Get("Retry-After"))
            time.Sleep(time.Duration(d) * time.Second)
            continue
        }
        b, _ := io.ReadAll(resp.Body)
        var out []string
        s := bufio.NewScanner(bufio.NewReader(strings.NewReader(string(b))))
        for s.Scan() { out = append(out, s.Text()) }
        return out, nil
    }
    return nil, fmt.Errorf("rate-limited twice")
}

func main() {
    subs, err := search(os.Args[1], os.Getenv("SUBMD_TOKEN"))
    if err != nil { fmt.Fprintln(os.Stderr, err); os.Exit(1) }
    for _, s := range subs { fmt.Println(s) }
}

// Node 18+ (built-in fetch)
async function search(apex, token) {
  const headers = { "Accept-Encoding": "gzip" };
  if (token) headers.Authorization = `Bearer ${token}`;
  const url = `https://api.sub.md/v1/search?apex=${encodeURIComponent(apex)}`;
  for (let i = 0; i < 2; i++) {
    const r = await fetch(url, { headers });
    if (r.status === 429) {
      await new Promise(res => setTimeout(res, parseInt(r.headers.get("Retry-After") || "2") * 1000));
      continue;
    }
    if (!r.ok) throw new Error(`HTTP ${r.status}`);
    return (await r.text()).split("\n").filter(Boolean);
  }
  throw new Error("rate-limited twice");
}

search(process.argv[2], process.env.SUBMD_TOKEN)
  .then(subs => subs.forEach(s => console.log(s)))
  .catch(e => { console.error(e.message); process.exit(1); });

// Cargo.toml: reqwest = { version = "0.12", features = ["blocking", "gzip"] }
use std::{env, thread, time::Duration};

fn search(apex: &str, token: Option<&str>) -> Result<Vec<String>, reqwest::Error> {
    let client = reqwest::blocking::Client::builder().gzip(true).build()?;
    let url = format!("https://api.sub.md/v1/search?apex={}", apex);
    for _ in 0..2 {
        let mut req = client.get(&url);
        if let Some(t) = token { req = req.bearer_auth(t); }
        let r = req.send()?;
        if r.status() == 429 {
            let d: u64 = r.headers().get("retry-after")
                .and_then(|v| v.to_str().ok()).and_then(|s| s.parse().ok()).unwrap_or(2);
            thread::sleep(Duration::from_secs(d));
            continue;
        }
        return Ok(r.error_for_status()?.text()?.lines().map(String::from).collect());
    }
    panic!("rate-limited twice");
}

fn main() {
    let apex = env::args().nth(1).expect("apex required");
    let tok = env::var("SUBMD_TOKEN").ok();
    for s in search(&apex, tok.as_deref()).unwrap() { println!("{}", s); }
}

# PowerShell 5.1+ / 7.x
function Get-SubmdSubdomains {
    param([string]$Apex, [string]$Token = $env:SUBMD_TOKEN)
    $headers = @{ "Accept-Encoding" = "gzip" }
    if ($Token) { $headers["Authorization"] = "Bearer $Token" }
    for ($i = 0; $i -lt 2; $i++) {
        try {
            $r = Invoke-WebRequest -Uri "https://api.sub.md/v1/search?apex=$Apex" `
                -Headers $headers -UseBasicParsing
            return $r.Content -split "`n" | Where-Object { $_ }
        } catch {
            if ($_.Exception.Response.StatusCode -eq 429) {
                $d = [int]($_.Exception.Response.Headers["Retry-After"] -as [string])
                if (-not $d) { $d = 2 }
                Start-Sleep -Seconds $d
                continue
            }
            throw
        }
    }
    throw "rate-limited twice"
}

Get-SubmdSubdomains -Apex $args[0]