Real-world audience data, one tool call away.

claude mcp add --transport http supermegamind https://supermegamind.com/api/mcp \
  --header "Authorization: Bearer smm_live_YOUR_KEY"

{
  "mcpServers": {
    "supermegamind": {
      "url": "https://supermegamind.com/api/mcp",
      "headers": { "Authorization": "Bearer smm_live_YOUR_KEY" }
    }
  }
}

{
  "mcpServers": {
    "supermegamind": {
      "command": "npx",
      "args": ["mcp-remote", "https://supermegamind.com/api/mcp", "--header", "Authorization:${SMM_AUTH}"],
      "env": { "SMM_AUTH": "Bearer smm_live_YOUR_KEY" }
    }
  }
}

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const client = new Client({ name: "my-agency-app", version: "1.0.0" });
await client.connect(
  new StreamableHTTPClientTransport(new URL("https://supermegamind.com/api/mcp"), {
    requestInit: { headers: { Authorization: `Bearer ${process.env.SMM_KEY}` } },
  })
);

const result = await client.callTool({
  name: "profile_list",
  arguments: { records }, // [{ email: "<sha256>" }, ...], hashed on your side
});

// A tool in YOUR app. The model passes a file reference and gets a profile back.
// The hashes never pass through the model, so the list can be up to 100,000 records.
import { readFileSync } from "node:fs";
import { parse } from "csv-parse/sync";
import { hashEmail, hashPhone, hashNameZip } from "./smm-hash"; // from the Hashing section

export async function profileCustomerFile(path: string) {
  const rows: Record<string, string>[] = parse(readFileSync(path), { columns: true });
  const records = rows
    .map((r) => ({
      email: hashEmail(r.email),
      phone: hashPhone(r.phone),
      namezip: hashNameZip(r.first_name, r.last_name, r.zip),
    }))
    .map((r) => Object.fromEntries(Object.entries(r).filter(([, v]) => v)))
    .filter((r) => Object.keys(r).length > 0)
    .slice(0, 100_000); // one run is at most 100,000 records

  const res = await fetch("https://supermegamind.com/api/v1/profiles", {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.SMM_KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify({ records }),
  });
  return res.json(); // give the model this: matched, attributes, claimUrl, usage
}

{
  "records": [
    { "email": "1a7694688f8c5a79b1adb2bdd23937bea3c3ebd27ab4108fa5190c105c21a3f2" },
    { "phone": "<sha256>", "namezip": "<sha256>" }
  ]
}

{
  "slug": "q3Xk9aLm",
  "claimUrl": "https://supermegamind.com/r/q3Xk9aLm/claim#t=...",
  "claimExpiresAt": "2026-10-21T18:04:11.000Z",
  "uploaded": 1200,
  "matched": 948,
  "matchRate": 79,
  "recordsBilled": 1200,
  "usage": { "used": 412000, "limit": 500000, "remaining": 88000,
             "resets": "2026-11-01T00:00:00.000Z", "overageEnabled": false },
  "attributes": [
    {
      "field": "CAMPING_ENTHUSIAST",
      "label": "Camping Enthusiast",
      "category": "Enthusiasts",
      "coverage": 54.9,
      "medianCustomer": null,
      "medianNational": null,
      "values": [
        { "label": "Y", "count": 520, "pct": 54.9, "index": 457, "decoded": true,
          "significant": true, "conservativeIndex": 422 }
      ]
    }
  ]
}

curl https://supermegamind.com/api/v1/attributes \
  -H "Authorization: Bearer $SMM_KEY"

curl https://supermegamind.com/api/v1/profiles \
  -H "Authorization: Bearer $SMM_KEY" \
  -H "Content-Type: application/json" \
  -d @body.json

import { createHash } from "node:crypto";

const sha256 = (s: string) => createHash("sha256").update(s, "utf8").digest("hex");

export function hashEmail(email?: string | null): string | null {
  const normalized = (email ?? "").trim().toLowerCase();
  return normalized ? sha256(normalized) : null;
}

export function hashPhone(phone?: string | null): string | null {
  let digits = (phone ?? "").replace(/\D/g, "");
  if (digits.length === 11 && digits.startsWith("1")) digits = digits.slice(1);
  return digits ? sha256(digits) : null;
}

export function hashNameZip(first?: string | null, last?: string | null, zip5?: string | null): string | null {
  const f = (first ?? "").toUpperCase().replace(/[^A-Z0-9]/g, "");
  const l = (last ?? "").toUpperCase().replace(/[^A-Z0-9]/g, "");
  if (!f || !l) return null;
  return sha256([f, l, (zip5 ?? "").trim().slice(0, 5)].join("|"));
}

import hashlib
import re


def _sha256(value: str) -> str:
    return hashlib.sha256(value.encode("utf-8")).hexdigest()


def hash_email(email):
    normalized = (email or "").strip().lower()
    return _sha256(normalized) if normalized else None


def hash_phone(phone):
    digits = re.sub(r"\D", "", phone or "", flags=re.ASCII)
    if len(digits) == 11 and digits.startswith("1"):
        digits = digits[1:]
    return _sha256(digits) if digits else None


def hash_namezip(first, last, zip5):
    first = re.sub(r"[^A-Z0-9]", "", (first or "").upper())
    last = re.sub(r"[^A-Z0-9]", "", (last or "").upper())
    if not first or not last:
        return None
    zip_ = (zip5 or "").strip()[:5]
    return _sha256("|".join([first, last, zip_]))

{ "error": { "code": "insufficient_matches", "message": "Fewer than 200 records matched, so no profile is returned." } }