scrapling-data 0.1.0__py3-none-any.whl

scrapling_data/__init__.py

@@ -0,0 +1,43 @@
+"""scrapling-data — lead-magnet SDK for Scrapling Data (https://scraplingdata.xyz).
+
+Free local address tools + thin x402 client. No scraping logic, no secrets.
+"""
+
+from scrapling_data.catalog import BASE_URL, DOCS_URL, PAID, catalog_summary, price_of
+from scrapling_data.client import ScraplingData
+from scrapling_data.local import (
+    AddressInfo,
+    chain_hint,
+    inspect_address,
+    is_ens_name,
+    is_evm_address,
+    is_solana_address,
+    lookalike_distance,
+    normalize_evm,
+    paid_teasers_for,
+    to_checksum_address,
+)
+from scrapling_data.x402 import PaymentRequired, PaymentRequiredError
+
+__version__ = "0.1.0"
+__all__ = [
+    "BASE_URL",
+    "DOCS_URL",
+    "PAID",
+    "AddressInfo",
+    "PaymentRequired",
+    "PaymentRequiredError",
+    "ScraplingData",
+    "catalog_summary",
+    "chain_hint",
+    "inspect_address",
+    "is_ens_name",
+    "is_evm_address",
+    "is_solana_address",
+    "lookalike_distance",
+    "normalize_evm",
+    "paid_teasers_for",
+    "price_of",
+    "to_checksum_address",
+    "__version__",
+]

scrapling_data/__main__.py

@@ -0,0 +1,3 @@
+from scrapling_data.cli import main
+
+raise SystemExit(main())

scrapling_data/_keccak.py

@@ -0,0 +1,73 @@
+"""Minimal Keccak-256 (Ethereum) for EIP-55 checksums. No third-party crypto deps."""
+
+from __future__ import annotations
+
+_RC = (
+    0x0000000000000001, 0x0000000000008082, 0x800000000000808A, 0x8000000080008000,
+    0x000000000000808B, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009,
+    0x000000000000008A, 0x0000000000000088, 0x0000000080008009, 0x000000008000000A,
+    0x000000008000808B, 0x800000000000008B, 0x8000000000008089, 0x8000000000008003,
+    0x8000000000008002, 0x8000000000000080, 0x000000000000800A, 0x800000008000000A,
+    0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008,
+)
+_ROT = (
+    (0, 36, 3, 41, 18),
+    (1, 44, 10, 45, 2),
+    (62, 6, 43, 15, 61),
+    (28, 55, 25, 21, 56),
+    (27, 20, 39, 8, 14),
+)
+
+
+def _rol64(x: int, n: int) -> int:
+    return ((x << n) | (x >> (64 - n))) & 0xFFFFFFFFFFFFFFFF
+
+
+def _keccak_f1600(st: list[int]) -> None:
+    for rnd in range(24):
+        c = [st[x] ^ st[x + 5] ^ st[x + 10] ^ st[x + 15] ^ st[x + 20] for x in range(5)]
+        d = [c[(x - 1) % 5] ^ _rol64(c[(x + 1) % 5], 1) for x in range(5)]
+        for i in range(25):
+            st[i] ^= d[i % 5]
+        b = [0] * 25
+        for x in range(5):
+            for y in range(5):
+                b[y + ((2 * x + 3 * y) % 5) * 5] = _rol64(st[x + 5 * y], _ROT[x][y])
+        for x in range(5):
+            for y in range(5):
+                i = x + 5 * y
+                st[i] = b[i] ^ ((~b[((x + 1) % 5) + 5 * y]) & b[((x + 2) % 5) + 5 * y])
+        st[0] ^= _RC[rnd]
+
+
+def _absorb_block(st: list[int], block: bytes) -> None:
+    for i in range(0, len(block), 8):
+        st[i // 8] ^= int.from_bytes(block[i : i + 8], "little")
+
+
+def keccak256(data: bytes) -> bytes:
+    """Return the 32-byte Keccak-256 digest of *data*."""
+    rate = 136
+    st = [0] * 25
+    offset = 0
+    n = len(data)
+    while offset + rate <= n:
+        _absorb_block(st, data[offset : offset + rate])
+        _keccak_f1600(st)
+        offset += rate
+    padded = bytearray(rate)
+    rem = data[offset:]
+    padded[: len(rem)] = rem
+    padded[len(rem)] = 0x01
+    padded[-1] |= 0x80
+    _absorb_block(st, bytes(padded))
+    _keccak_f1600(st)
+    out = bytearray()
+    while len(out) < 32:
+        for i in range(rate // 8):
+            out.extend(st[i].to_bytes(8, "little"))
+            if len(out) >= 32:
+                break
+        if len(out) < 32:
+            _keccak_f1600(st)
+    return bytes(out[:32])

scrapling_data/catalog.py

@@ -0,0 +1,163 @@
+"""Endpoint catalog with live prices (sourced Nov 5–6 2026 from scraplingdata.xyz).
+
+Prices match BRIEF.md + /llms.txt + OpenAPI x-payment-info. Always prefer the
+HTTP 402 PAYMENT-REQUIRED amount at call time over these hints.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+BASE_URL = "https://scraplingdata.xyz"
+DOCS_URL = f"{BASE_URL}/docs"
+TEST_BUY_URL = f"{BASE_URL}/test-buy"
+X402_MANIFEST = f"{BASE_URL}/.well-known/x402"
+MCP_URL = f"{BASE_URL}/mcp"
+PAY_TO_EVM = "0x72C80C01fD89Bac74f47cf604b61ACd119c9BCdb"
+PAY_TO_SOLANA = "4ZUtqtQSrL522bcXTag1eR59cwfQhQGW16nYuzyYgRWX"
+
+# path -> price USD (hints; 402 response is authoritative)
+PAID: Dict[str, float] = {
+    "/v1/lookup/address-poisoning": 0.0009,
+    "/v1/lookup/coin": 0.001,
+    "/v1/lookup/protocol": 0.001,
+    "/v1/lookup/pool": 0.001,
+    "/v1/bundle/market-pulse": 0.001,
+    "/v1/bundle/defi-intel": 0.001,
+    "/v1/token/holders": 0.001,
+    "/v1/ping": 0.001,
+    "/v1/stocks/price": 0.001,
+    "/v1/lookup/ens": 0.001,
+    "/v1/lookup/evm-address": 0.001,
+    "/v1/lookup/fx": 0.001,
+    "/v1/tombstones/check": 0.001,
+    "/v1/lookup/yields": 0.002,
+    "/v1/ads/cost-benchmarks": 0.002,
+    "/v1/alerts/price-moves": 0.002,
+    "/v1/wallet-label": 0.002,
+    "/v1/lookup/evm-balance": 0.002,
+    "/v1/lookup/news": 0.002,
+    "/v1/lookup/market-overview": 0.002,
+    "/v1/stocks/filings": 0.003,
+    "/v1/traders/wallet": 0.003,
+    "/v1/lookup/prices": 0.003,
+    "/v1/company": 0.003,
+    "/v1/lookup/web-search": 0.003,
+    "/v1/scrape/text": 0.003,
+    "/v1/check/counterparty": 0.004,
+    "/v1/intel/risk-check": 0.0045,
+    "/v1/lookup/polymarket": 0.005,
+    "/v1/lookup/token-risk": 0.005,
+    "/v1/whales/moves": 0.005,
+    "/v1/whales/token": 0.005,
+    "/v1/token/verdict": 0.005,
+    "/v1/wallet/profile": 0.005,
+    "/v1/yields/staking": 0.005,
+    "/v1/meme/trending": 0.005,
+    "/v1/meme/pumpfun": 0.005,
+    "/v1/meme/new-pools": 0.005,
+    "/v1/stocks/fundamentals": 0.005,
+    "/v1/stocks/insiders": 0.005,
+    "/v1/traders/top": 0.005,
+    "/v1/lookup/tokenized-stocks": 0.005,
+    "/v1/lookup/crypto-treasuries": 0.005,
+    "/v1/lookup/tokenized-real-estate": 0.005,
+    "/v1/lookup/candles": 0.005,
+    "/v1/lookup/pdf": 0.005,
+    "/v1/lookup/youtube-transcript": 0.005,
+    "/v1/lookup/domain": 0.005,
+    "/v1/ecom/product": 0.01,
+    "/v1/yields/pendle": 0.01,
+    "/v1/perps/funding": 0.01,
+    "/v1/meme/history": 0.01,
+    "/v1/signals/whale-netflow": 0.02,
+    "/v1/regime/now": 0.02,
+    "/v1/ecom/changes": 0.02,
+    "/v1/lookup/binance-flows": 0.02,
+    "/v1/lookup/hack-tracker": 0.03,
+    "/v1/trust/agent": 0.04,
+    "/v1/regime/full": 0.05,
+    "/v1/ecom/snapshot": 0.05,
+    "/v1/wallet-label/bulk": 0.05,
+    "/v1/intel/risk-check/batch": 0.15,
+    "/v1/dd/quick": 0.25,
+    "/v1/ecom/catalog": 0.25,
+    "/v1/lookup/binance-flows/report": 0.25,
+    "/v1/dd/report": 1.0,
+    "/v1/pass/day": 2.0,
+    "/v1/alerts/subscribe/week": 5.0,
+    "/v1/bundles/defi-yields-pools-snapshot/download": 5.0,
+    "/v1/bundles/hack-tracker-export/download": 10.0,
+    "/v1/bundles/tokenized-assets-snapshot/download": 10.0,
+    "/v1/bundles/stolen-funds/download": 12.0,
+    "/v1/alerts/subscribe/month": 15.0,
+    "/v1/bundles/wallet-labels-full/download": 15.0,
+    "/v1/pass/month": 25.0,
+    "/v1/bundles/all-in-crypto-data/download": 25.0,
+}
+
+FREE_PATHS = [
+    "/v1/free/ping",
+    "/v1/free/feeds",
+    "/v1/free/crypto/top10",
+    "/v1/free/defi/top-yields",
+    "/v1/free/regime",
+    "/v1/free/staking-yields",
+    "/v1/free/funding",
+    "/v1/free/meme-trending",
+    "/v1/free/stocks",
+    "/v1/free/traders",
+    "/v1/free/tokenized-stocks",
+    "/v1/free/crypto-treasuries",
+    "/v1/free/tokenized-real-estate",
+    "/v1/free/hack-tracker",
+    "/v1/free/hack-tracker/alerts",
+    "/v1/free/prices",
+    "/v1/free/address-poisoning",
+    "/v1/free/wallet-label",
+    "/v1/free/company",
+    "/v1/free/intel/risk-check",
+    "/v1/free/binance-flows",
+    "/v1/free/candles",
+    "/v1/free/ens",
+    "/v1/free/fx",
+    "/v1/free/news",
+    "/v1/free/market-overview",
+    "/v1/free/ecom",
+    "/v1/free/ecom/stores",
+    "/v1/free/alerts",
+    "/v1/free/labels/changelog",
+    "/v1/quality",
+    "/v1/bundles",
+    "/v1/datasets",
+]
+
+
+def price_of(path: str) -> Optional[float]:
+    """Return catalog hint price for a path, or None if unknown / free."""
+    path = path.split("?")[0]
+    if not path.startswith("/"):
+        path = "/" + path
+    return PAID.get(path)
+
+
+def catalog_summary() -> Dict[str, Any]:
+    return {
+        "base_url": BASE_URL,
+        "docs": DOCS_URL,
+        "mcp": MCP_URL,
+        "x402_manifest": X402_MANIFEST,
+        "pay_to_evm": PAY_TO_EVM,
+        "pay_to_solana": PAY_TO_SOLANA,
+        "paid_routes": len(PAID),
+        "free_routes": len(FREE_PATHS),
+        "note": "402 PAYMENT-REQUIRED amount is authoritative; these are catalog hints.",
+        "source": "https://scraplingdata.xyz/llms.txt + /openapi.json + company BRIEF (2026-11-05/06)",
+    }
+
+
+def list_paid(max_price: Optional[float] = None) -> List[Dict[str, Any]]:
+    items = [{"path": p, "price_usd": v} for p, v in sorted(PAID.items(), key=lambda kv: (kv[1], kv[0]))]
+    if max_price is not None:
+        items = [i for i in items if i["price_usd"] <= max_price]
+    return items

scrapling_data/cli.py

@@ -0,0 +1,178 @@
+"""CLI entrypoint: scrapling-data check <address>"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any, Dict, List
+
+from scrapling_data import catalog
+from scrapling_data.client import ScraplingData
+from scrapling_data.local import inspect_address, lookalike_distance, paid_teasers_for
+
+
+def _print_json(data: Any) -> None:
+    print(json.dumps(data, indent=2, default=str))
+
+
+def cmd_check(args: argparse.Namespace) -> int:
+    info = inspect_address(args.address)
+    report: Dict[str, Any] = {
+        "local": info.to_dict(),
+        "store": catalog.BASE_URL,
+        "free": {},
+        "paid_teasers": paid_teasers_for(info.kind),
+        "how_to_pay": {
+            "protocol": "x402 USDC (Base preferred)",
+            "docs": catalog.DOCS_URL,
+            "test_buy": catalog.TEST_BUY_URL,
+            "sdk": "ScraplingData(payment_handler=...)",
+        },
+    }
+
+    if args.compare:
+        try:
+            report["lookalike"] = lookalike_distance(args.address, args.compare)
+        except ValueError as e:
+            report["lookalike_error"] = str(e)
+
+    if not args.offline and info.valid and info.kind in {"evm", "solana"}:
+        addr = info.checksum or info.normalized or args.address
+        with ScraplingData(timeout=args.timeout) as client:
+            try:
+                report["free"]["wallet_label"] = client.free_wallet_label(addr)
+            except Exception as e:  # noqa: BLE001 — CLI should stay useful offline-ish
+                report["free"]["wallet_label_error"] = str(e)
+            try:
+                risk = client.free_intel_risk_check(addr)
+                report["free"]["intel_risk_check"] = risk
+            except Exception as e:  # noqa: BLE001
+                report["free"]["intel_risk_check_error"] = str(e)
+            if info.kind == "evm":
+                try:
+                    report["free"]["address_poisoning_sample"] = client.free_address_poisoning(addr)
+                except Exception as e:  # noqa: BLE001
+                    report["free"]["address_poisoning_error"] = str(e)
+
+    if args.json:
+        _print_json(report)
+        return 0
+
+    # Human-friendly teaser output
+    print(f"Scrapling Data check — {catalog.BASE_URL}")
+    print("=" * 56)
+    print(f"input:      {info.input}")
+    print(f"kind:       {info.kind}")
+    print(f"valid:      {info.valid}")
+    if info.normalized:
+        print(f"normalized: {info.normalized}")
+    if info.checksum:
+        print(f"checksum:   {info.checksum}")
+    if info.checksum_ok is not None:
+        print(f"eip55_ok:   {info.checksum_ok}")
+    for n in info.notes:
+        print(f"note:       {n}")
+
+    if "lookalike" in report:
+        la = report["lookalike"]
+        print()
+        print(f"lookalike vs compare: {la['verdict']} (score {la['poison_lookalike_score_0_100']})")
+        print(f"  prefix={la['matching_prefix_chars']} suffix={la['matching_suffix_chars']} hamming={la['hamming_hex_chars']}")
+
+    free = report.get("free") or {}
+    if free.get("wallet_label"):
+        wl = free["wallet_label"]
+        print()
+        print("FREE wallet-label teaser:")
+        print(f"  entity={wl.get('entity')} category={wl.get('category')} match={wl.get('match')}")
+        print("  (paid /v1/wallet-label $0.002 adds confidence + sources)")
+    if free.get("intel_risk_check") and isinstance(free["intel_risk_check"], dict):
+        rk = free["intel_risk_check"]
+        if rk.get("error") == "payment_required":
+            print()
+            print(f"FREE intel risk-check: daily free tries used → {rk.get('message')}")
+        else:
+            print()
+            print("FREE intel risk-check teaser:")
+            data = rk.get("data") if isinstance(rk.get("data"), dict) else rk
+            verdict = data.get("verdict") or data.get("risk") or rk.get("verdict")
+            score = data.get("risk_score")
+            entity = data.get("entity") or data.get("primary_label")
+            remaining = rk.get("free_tries_remaining_today_utc")
+            bits = []
+            if verdict is not None:
+                bits.append(f"verdict={verdict}")
+            if score is not None:
+                bits.append(f"score={score}")
+            if entity is not None:
+                bits.append(f"entity={entity}")
+            if remaining is not None:
+                bits.append(f"free_left_today={remaining}")
+            print("  " + ("  ".join(bits) if bits else json.dumps(rk, default=str)[:240]))
+            print("  (paid /v1/intel/risk-check $0.0045 after 3 free/IP/day)")
+
+    print()
+    print("Paid unlocks (x402 USDC, no API key):")
+    for t in report["paid_teasers"][:6]:
+        print(f"  ${t['price_usd']:<7}  {t['path']:<36}  {t['blurb']}")
+    print()
+    print(f"Docs: {catalog.DOCS_URL}")
+    print(f"Pay flow test: {catalog.TEST_BUY_URL}")
+    print("Python: from scrapling_data import ScraplingData")
+    return 0
+
+
+def cmd_catalog(args: argparse.Namespace) -> int:
+    data = catalog.catalog_summary()
+    if args.max_price is not None:
+        data["routes"] = catalog.list_paid(max_price=args.max_price)
+    else:
+        data["sample_routes"] = catalog.list_paid()[:15]
+        data["hint"] = "pass --max-price 0.01 to list cheap routes"
+    _print_json(data)
+    return 0
+
+
+def cmd_ping(args: argparse.Namespace) -> int:
+    with ScraplingData(timeout=args.timeout) as client:
+        _print_json(client.free_ping())
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="scrapling-data",
+        description="Free address tools + teaser for Scrapling Data x402 crypto intel (scraplingdata.xyz).",
+    )
+    p.add_argument("--timeout", type=float, default=30.0)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    c = sub.add_parser("check", help="Local validate + free teasers + paid price menu for an address")
+    c.add_argument("address", help="EVM address, Solana address, or ENS name")
+    c.add_argument("--compare", help="Second EVM address for free lookalike / poisoning heuristic")
+    c.add_argument("--offline", action="store_true", help="Skip free network teasers")
+    c.add_argument("--json", action="store_true", help="Machine-readable JSON")
+    c.set_defaults(func=cmd_check)
+
+    cat = sub.add_parser("catalog", help="Show store catalog summary / cheap routes")
+    cat.add_argument("--max-price", type=float, default=None)
+    cat.set_defaults(func=cmd_catalog)
+
+    ping = sub.add_parser("ping", help="Hit free /v1/free/ping")
+    ping.set_defaults(func=cmd_ping)
+
+    return p
+
+
+def main(argv: List[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        return int(args.func(args))
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scrapling_data/client.py

@@ -0,0 +1,253 @@
+"""HTTP client for Scrapling Data free + paid (x402) routes."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Mapping, Optional, Union
+from urllib.parse import urlencode
+
+import httpx
+
+from scrapling_data import catalog
+from scrapling_data.x402 import PaymentHandler, PaymentRequiredError, parse_402
+
+
+class ScraplingData:
+    """
+    Thin public SDK for https://scraplingdata.xyz.
+
+    Free routes need no wallet. Paid routes return HTTP 402 unless you pass
+    ``payment_handler`` (returns a PAYMENT-SIGNATURE value) or ``pass_token`` /
+    ``api_key``. This library never holds private keys.
+    """
+
+    def __init__(
+        self,
+        base_url: str = catalog.BASE_URL,
+        *,
+        timeout: float = 60.0,
+        payment_handler: Optional[PaymentHandler] = None,
+        pass_token: Optional[str] = None,
+        api_key: Optional[str] = None,
+        trial_code: Optional[str] = None,
+        client: Optional[httpx.Client] = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.payment_handler = payment_handler
+        self.pass_token = pass_token
+        self.api_key = api_key
+        self.trial_code = trial_code
+        self._owns_client = client is None
+        self._client = client or httpx.Client(timeout=timeout, headers={"User-Agent": "scrapling-data-sdk/0.1.0"})
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def __enter__(self) -> "ScraplingData":
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    # ---- core transport -------------------------------------------------
+    def _auth_headers(self) -> Dict[str, str]:
+        h: Dict[str, str] = {}
+        if self.pass_token:
+            h["X-Pass-Token"] = self.pass_token
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        if self.trial_code:
+            h["X-Trial-Code"] = self.trial_code
+        return h
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[Mapping[str, Any]] = None,
+        json_body: Any = None,
+        headers: Optional[Mapping[str, str]] = None,
+        raise_on_402: bool = True,
+    ) -> Any:
+        """Low-level request. On 402: try payment_handler once, else raise or return challenge."""
+        if not path.startswith("/"):
+            path = "/" + path
+        url = self.base_url + path
+        clean_params = None
+        if params:
+            clean_params = {k: v for k, v in params.items() if v is not None}
+
+        hdrs = self._auth_headers()
+        if headers:
+            hdrs.update(dict(headers))
+
+        resp = self._client.request(method.upper(), url, params=clean_params, json=json_body, headers=hdrs)
+        if resp.status_code != 402:
+            resp.raise_for_status()
+            if not resp.content:
+                return None
+            ctype = resp.headers.get("content-type", "")
+            return resp.json() if "json" in ctype else resp.text
+
+        body: Any
+        try:
+            body = resp.json()
+        except Exception:
+            body = resp.text
+        payment = parse_402(path, resp.status_code, dict(resp.headers), body)
+
+        if self.payment_handler is not None:
+            signature = self.payment_handler(payment)
+            hdrs2 = dict(hdrs)
+            hdrs2["PAYMENT-SIGNATURE"] = signature
+            # Some clients still send X-PAYMENT
+            hdrs2.setdefault("X-PAYMENT", signature)
+            resp2 = self._client.request(method.upper(), url, params=clean_params, json=json_body, headers=hdrs2)
+            if resp2.status_code == 402:
+                body2: Any
+                try:
+                    body2 = resp2.json()
+                except Exception:
+                    body2 = resp2.text
+                payment2 = parse_402(path, resp2.status_code, dict(resp2.headers), body2)
+                if raise_on_402:
+                    raise PaymentRequiredError(payment2)
+                return payment2.to_dict()
+            resp2.raise_for_status()
+            return resp2.json() if resp2.content else None
+
+        if raise_on_402:
+            raise PaymentRequiredError(payment)
+        return payment.to_dict()
+
+    def get(self, path: str, **params: Any) -> Any:
+        return self.request("GET", path, params=params)
+
+    def get_soft(self, path: str, **params: Any) -> Any:
+        """Like get(), but return a payment-required dict instead of raising."""
+        return self.request("GET", path, params=params, raise_on_402=False)
+
+    # ---- free helpers ---------------------------------------------------
+    def free_ping(self) -> Any:
+        return self.get("/v1/free/ping")
+
+    def free_feeds(self) -> Any:
+        return self.get("/v1/free/feeds")
+
+    def free_crypto_top10(self) -> Any:
+        return self.get("/v1/free/crypto/top10")
+
+    def free_defi_top_yields(self) -> Any:
+        return self.get("/v1/free/defi/top-yields")
+
+    def free_wallet_label(self, address: str) -> Any:
+        return self.get("/v1/free/wallet-label", address=address)
+
+    def free_intel_risk_check(self, address: str) -> Any:
+        """3 free/IP/UTC-day, then 402 at $0.0045."""
+        return self.get_soft("/v1/free/intel/risk-check", address=address)
+
+    def free_hack_tracker(self, incident: str = "binance-2026") -> Any:
+        return self.get("/v1/free/hack-tracker", incident=incident)
+
+    def free_market_overview(self) -> Any:
+        return self.get("/v1/free/market-overview")
+
+    def free_address_poisoning(self, address: str) -> Any:
+        return self.get("/v1/free/address-poisoning", address=address)
+
+    def free_ens(self) -> Any:
+        return self.get("/v1/free/ens")
+
+    def free_prices(self, tokens: str = "btc,eth,sol") -> Any:
+        return self.get("/v1/free/prices", tokens=tokens)
+
+    # ---- paid methods (x402) --------------------------------------------
+    def counterparty(self, address: str, chain: str = "ethereum") -> Any:
+        return self.get("/v1/check/counterparty", address=address, chain=chain)
+
+    def wallet_label(self, address: str) -> Any:
+        return self.get("/v1/wallet-label", address=address)
+
+    def wallet_profile(self, address: str, chain: str = "ethereum") -> Any:
+        return self.get("/v1/wallet/profile", address=address, chain=chain)
+
+    def intel_risk_check(self, address: str) -> Any:
+        return self.get("/v1/intel/risk-check", address=address)
+
+    def intel_risk_batch(self, addresses: str) -> Any:
+        return self.get("/v1/intel/risk-check/batch", addresses=addresses)
+
+    def hack_tracker(self, incident: str = "binance-2026", limit: int = 100) -> Any:
+        return self.get("/v1/lookup/hack-tracker", incident=incident, limit=limit)
+
+    def market_pulse(self) -> Any:
+        return self.get("/v1/bundle/market-pulse")
+
+    def defi_intel(self) -> Any:
+        return self.get("/v1/bundle/defi-intel")
+
+    def yields(self, chain: Optional[str] = None, token: Optional[str] = None) -> Any:
+        return self.get("/v1/lookup/yields", chain=chain, token=token)
+
+    def tokenized_stocks(self, ticker: Optional[str] = None, **kw: Any) -> Any:
+        return self.get("/v1/lookup/tokenized-stocks", ticker=ticker, **kw)
+
+    def crypto_treasuries(self, asset: Optional[str] = None, **kw: Any) -> Any:
+        return self.get("/v1/lookup/crypto-treasuries", asset=asset, **kw)
+
+    def tokenized_real_estate(self, city: Optional[str] = None, **kw: Any) -> Any:
+        return self.get("/v1/lookup/tokenized-real-estate", city=city, **kw)
+
+    def token_verdict(self, address: str, chain: str = "base") -> Any:
+        return self.get("/v1/token/verdict", address=address, chain=chain)
+
+    def token_risk(self, address: str) -> Any:
+        return self.get("/v1/lookup/token-risk", address=address)
+
+    def trust_agent(self, address: str, chain: str = "base") -> Any:
+        return self.get("/v1/trust/agent", address=address, chain=chain)
+
+    def coin(self, q: str) -> Any:
+        return self.get("/v1/lookup/coin", q=q)
+
+    def protocol(self, q: str) -> Any:
+        return self.get("/v1/lookup/protocol", q=q)
+
+    def ens(self, name: Optional[str] = None, address: Optional[str] = None) -> Any:
+        return self.get("/v1/lookup/ens", name=name, address=address)
+
+    def address_poisoning(self, address: str, hours: int = 6) -> Any:
+        return self.get("/v1/lookup/address-poisoning", address=address, hours=hours)
+
+    def whale_moves(self, min_usd: float = 100000, window: str = "1h", **kw: Any) -> Any:
+        return self.get("/v1/whales/moves", min_usd=min_usd, window=window, **kw)
+
+    def whale_netflow(self, chain: str = "all", window: str = "24h", **kw: Any) -> Any:
+        return self.get("/v1/signals/whale-netflow", chain=chain, window=window, **kw)
+
+    def regime_now(self) -> Any:
+        return self.get("/v1/regime/now")
+
+    def dd_quick(self, address: str, chain: str = "base") -> Any:
+        return self.get("/v1/dd/quick", address=address, chain=chain)
+
+    def dd_report(self, address: str, chain: str = "base") -> Any:
+        return self.get("/v1/dd/report", address=address, chain=chain)
+
+    def ping(self) -> Any:
+        """Cheapest paid call ($0.001) — payment smoke test."""
+        return self.get("/v1/ping")
+
+    def pass_day(self) -> Any:
+        return self.get("/v1/pass/day")
+
+    def pass_month(self) -> Any:
+        return self.get("/v1/pass/month")
+
+    def url(self, path: str, **params: Any) -> str:
+        if not path.startswith("/"):
+            path = "/" + path
+        q = urlencode({k: v for k, v in params.items() if v is not None})
+        return self.base_url + path + (("?" + q) if q else "")

scrapling_data/local.py

@@ -0,0 +1,284 @@
+"""Free local helpers — no network, no payment. Sticky first taste of Scrapling Data."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List, Optional
+
+from scrapling_data._keccak import keccak256
+
+_HEX40 = re.compile(r"^0x[0-9a-fA-F]{40}$")
+_HEX_BARE = re.compile(r"^[0-9a-fA-F]{40}$")
+# Solana base58 addresses are typically 32–44 chars; exclude pure hex/EVM.
+_B58 = re.compile(r"^[1-9A-HJ-NP-Za-km-z]{32,44}$")
+_ENS = re.compile(r"^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$", re.I)
+
+# Well-known chain ids (hints only — not a network call).
+CHAIN_IDS = {
+    "ethereum": 1,
+    "base": 8453,
+    "polygon": 137,
+    "arbitrum": 42161,
+    "optimism": 10,
+    "bsc": 56,
+    "avalanche": 43114,
+    "gnosis": 100,
+}
+
+ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
+
+
+@dataclass(frozen=True)
+class AddressInfo:
+    """Result of free local address inspection."""
+
+    input: str
+    kind: str  # evm | solana | ens | unknown
+    valid: bool
+    normalized: Optional[str] = None
+    checksum: Optional[str] = None
+    checksum_ok: Optional[bool] = None
+    is_zero: bool = False
+    notes: tuple = ()
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        d["notes"] = list(self.notes)
+        return d
+
+
+def is_evm_address(value: str) -> bool:
+    """True if *value* looks like a 20-byte EVM address (with or without 0x)."""
+    if not isinstance(value, str):
+        return False
+    v = value.strip()
+    return bool(_HEX40.match(v) or _HEX_BARE.match(v))
+
+
+def is_solana_address(value: str) -> bool:
+    """Heuristic: base58 length typical of Solana pubkeys, not an EVM hex address."""
+    if not isinstance(value, str):
+        return False
+    v = value.strip()
+    if is_evm_address(v) or "." in v:
+        return False
+    return bool(_B58.match(v))
+
+
+def is_ens_name(value: str) -> bool:
+    if not isinstance(value, str):
+        return False
+    v = value.strip().lower()
+    return bool(_ENS.match(v) and "." in v and " " not in v)
+
+
+def to_checksum_address(address: str) -> str:
+    """EIP-55 checksum encoding. Raises ValueError on bad input."""
+    if not is_evm_address(address):
+        raise ValueError(f"not an EVM address: {address!r}")
+    hex_part = address.strip().lower().replace("0x", "")
+    digest = keccak256(hex_part.encode("ascii")).hex()
+    out = ["0x"]
+    for i, ch in enumerate(hex_part):
+        if ch in "0123456789":
+            out.append(ch)
+        else:
+            out.append(ch.upper() if int(digest[i], 16) >= 8 else ch)
+    return "".join(out)
+
+
+def normalize_evm(address: str) -> str:
+    """Lowercase 0x-prefixed EVM address."""
+    if not is_evm_address(address):
+        raise ValueError(f"not an EVM address: {address!r}")
+    v = address.strip()
+    if not v.startswith("0x") and not v.startswith("0X"):
+        v = "0x" + v
+    return "0x" + v[2:].lower()
+
+
+def lookalike_distance(a: str, b: str) -> Dict[str, Any]:
+    """
+    Free address-poisoning heuristic: how similar are two EVM addresses?
+
+    Compares first/last nibbles (what wallets show truncated) and Hamming distance
+    on the full hex. High head+tail overlap with a different middle is a classic
+    poisoning pattern. Does NOT call any API.
+    """
+    if not (is_evm_address(a) and is_evm_address(b)):
+        raise ValueError("both inputs must be EVM addresses")
+    aa = normalize_evm(a)[2:]
+    bb = normalize_evm(b)[2:]
+    hamming = sum(x != y for x, y in zip(aa, bb))
+    head = 0
+    for x, y in zip(aa, bb):
+        if x != y:
+            break
+        head += 1
+    tail = 0
+    for x, y in zip(aa[::-1], bb[::-1]):
+        if x != y:
+            break
+        tail += 1
+    # Score 0–100: identical head/tail with different middle = suspicious.
+    same = a.lower() == b.lower()
+    poison_score = 0
+    if not same:
+        poison_score = min(100, head * 4 + tail * 4 - hamming)
+        poison_score = max(0, poison_score)
+    return {
+        "a": to_checksum_address(a),
+        "b": to_checksum_address(b),
+        "identical": same,
+        "hamming_hex_chars": hamming,
+        "matching_prefix_chars": head,
+        "matching_suffix_chars": tail,
+        "poison_lookalike_score_0_100": poison_score,
+        "verdict": (
+            "identical"
+            if same
+            else "high_lookalike_risk"
+            if poison_score >= 60
+            else "moderate_lookalike"
+            if poison_score >= 30
+            else "distinct"
+        ),
+        "upgrade": {
+            "endpoint": "/v1/lookup/address-poisoning",
+            "price_usd": 0.0009,
+            "why": "Live Base USDC transfer lookalike flags with tx hashes (paid via x402).",
+            "docs": "https://scraplingdata.xyz/docs",
+        },
+    }
+
+
+def detect_kind(value: str) -> str:
+    if is_evm_address(value):
+        return "evm"
+    if is_ens_name(value):
+        return "ens"
+    if is_solana_address(value):
+        return "solana"
+    return "unknown"
+
+
+def inspect_address(value: str) -> AddressInfo:
+    """Free local inspection of an address / ENS name."""
+    raw = (value or "").strip()
+    kind = detect_kind(raw)
+    notes: List[str] = []
+    if kind == "evm":
+        norm = normalize_evm(raw)
+        checksum = to_checksum_address(norm)
+        body = raw[2:] if raw.lower().startswith("0x") else raw
+        mixed = any(c.isupper() for c in body) and any(c.islower() for c in body)
+        checksum_ok = (body == checksum[2:]) if mixed else None
+        is_zero = norm == ZERO_ADDRESS
+        if is_zero:
+            notes.append("This is the zero address — usually invalid as a counterparty.")
+        if mixed and checksum_ok is False:
+            notes.append("Mixed-case address fails EIP-55 checksum — treat with caution.")
+        notes.append(
+            "Free local check only. Paid counterparty / risk-check / wallet-label add real intel."
+        )
+        return AddressInfo(
+            input=raw,
+            kind="evm",
+            valid=True,
+            normalized=norm,
+            checksum=checksum,
+            checksum_ok=checksum_ok,
+            is_zero=is_zero,
+            notes=tuple(notes),
+        )
+    if kind == "ens":
+        notes.append("ENS name detected — resolve with free /v1/free/ens sample or paid /v1/lookup/ens ($0.001).")
+        return AddressInfo(input=raw, kind="ens", valid=True, normalized=raw.lower(), notes=tuple(notes))
+    if kind == "solana":
+        notes.append("Solana-looking address — use chain=solana on counterparty / wallet profile / holders.")
+        return AddressInfo(input=raw, kind="solana", valid=True, normalized=raw, notes=tuple(notes))
+    notes.append("Could not classify. Pass an EVM 0x address, Solana base58, or ENS name.")
+    return AddressInfo(input=raw, kind="unknown", valid=False, notes=tuple(notes))
+
+
+def chain_hint(name_or_id: str | int) -> Dict[str, Any]:
+    """Map a chain name or id to a hint dict (local only)."""
+    if isinstance(name_or_id, int):
+        for name, cid in CHAIN_IDS.items():
+            if cid == name_or_id:
+                return {"name": name, "chain_id": cid, "source": "local"}
+        return {"name": None, "chain_id": name_or_id, "source": "local", "known": False}
+    key = str(name_or_id).strip().lower()
+    aliases = {"eth": "ethereum", "arb": "arbitrum", "matic": "polygon", "avax": "avalanche", "bnb": "bsc"}
+    key = aliases.get(key, key)
+    if key in CHAIN_IDS:
+        return {"name": key, "chain_id": CHAIN_IDS[key], "source": "local", "known": True}
+    return {"name": key, "chain_id": None, "source": "local", "known": False}
+
+
+def paid_teasers_for(kind: str) -> List[Dict[str, Any]]:
+    """What paid Scrapling Data calls unlock next — used by CLI and agents."""
+    common = [
+        {
+            "name": "counterparty_check",
+            "path": "/v1/check/counterparty",
+            "price_usd": 0.004,
+            "blurb": "safe / caution / block + score before you pay or trade",
+        },
+        {
+            "name": "intel_risk_check",
+            "path": "/v1/intel/risk-check",
+            "price_usd": 0.0045,
+            "blurb": "MALICIOUS / HIGH_RISK / WATCH / LOW_RISK (3 free/IP/day)",
+            "free_teaser": "/v1/free/intel/risk-check",
+        },
+        {
+            "name": "wallet_label",
+            "path": "/v1/wallet-label",
+            "price_usd": 0.002,
+            "blurb": "entity, category, confidence, source links",
+            "free_teaser": "/v1/free/wallet-label",
+        },
+        {
+            "name": "wallet_profile",
+            "path": "/v1/wallet/profile",
+            "price_usd": 0.005,
+            "blurb": "exchange/whale/trader/fresh/dormant + activity score",
+        },
+        {
+            "name": "hack_tracker",
+            "path": "/v1/lookup/hack-tracker",
+            "price_usd": 0.03,
+            "blurb": "stolen-funds tracker (attacker wallets, swaps, CEX alerts)",
+            "free_teaser": "/v1/free/hack-tracker",
+        },
+        {
+            "name": "trust_agent",
+            "path": "/v1/trust/agent",
+            "price_usd": 0.04,
+            "blurb": "allow / caution / block trust bundle for agents",
+        },
+    ]
+    if kind == "solana":
+        common.insert(
+            1,
+            {
+                "name": "token_holders",
+                "path": "/v1/token/holders",
+                "price_usd": 0.001,
+                "blurb": "Solana holder concentration + exchange-held share",
+            },
+        )
+    if kind == "ens":
+        return [
+            {
+                "name": "ens_lookup",
+                "path": "/v1/lookup/ens",
+                "price_usd": 0.001,
+                "blurb": "resolve any ENS name or reverse-resolve an address",
+                "free_teaser": "/v1/free/ens",
+            },
+            *common[:3],
+        ]
+    return common

scrapling_data/x402.py

@@ -0,0 +1,132 @@
+"""x402 payment-required parsing and helpers (no private keys, no auto-signing)."""
+
+from __future__ import annotations
+
+import base64
+import json
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from scrapling_data import catalog
+
+PaymentHandler = Callable[["PaymentRequired"], str]
+# Handler returns the value for the PAYMENT-SIGNATURE header (or X-PAYMENT).
+
+
+@dataclass
+class PaymentRequired:
+    """Parsed HTTP 402 challenge from Scrapling Data."""
+
+    status_code: int
+    path: str
+    body: Dict[str, Any]
+    payment_required_header: Optional[str] = None
+    accepts: List[Dict[str, Any]] = field(default_factory=list)
+    price_usd_hint: Optional[float] = None
+    message: str = ""
+
+    def preferred_accept(self) -> Optional[Dict[str, Any]]:
+        """Prefer Base (eip155:8453) USDC exact payment when listed."""
+        if not self.accepts:
+            return None
+        for a in self.accepts:
+            if a.get("network") == "eip155:8453" and a.get("scheme") == "exact":
+                return a
+        return self.accepts[0]
+
+    def to_dict(self) -> Dict[str, Any]:
+        pref = self.preferred_accept()
+        return {
+            "error": "payment_required",
+            "status_code": self.status_code,
+            "path": self.path,
+            "price_usd_hint": self.price_usd_hint,
+            "message": self.message,
+            "accepts": self.accepts,
+            "preferred": pref,
+            "how_to_pay": {
+                "steps": [
+                    "Pick one entry from accepts (Base eip155:8453 USDC preferred).",
+                    "Sign an x402 exact payment with your wallet/signer (never paste a private key into this library).",
+                    "Retry the same request with header PAYMENT-SIGNATURE: <signed payload>.",
+                    "Or use day/month pass: /v1/pass/day ($2) / /v1/pass/month ($25).",
+                ],
+                "docs": catalog.DOCS_URL,
+                "test_buy": catalog.TEST_BUY_URL,
+                "manifest": catalog.X402_MANIFEST,
+                "python_hint": "client = ScraplingData(payment_handler=your_signer_fn)",
+            },
+            "body": self.body,
+        }
+
+
+class PaymentRequiredError(Exception):
+    """Raised when a paid route returns 402 and no payment_handler settled it."""
+
+    def __init__(self, payment: PaymentRequired):
+        self.payment = payment
+        super().__init__(payment.message or "Payment required (x402)")
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self.payment.to_dict()
+
+
+def _b64json(header_val: str) -> Optional[Dict[str, Any]]:
+    try:
+        raw = base64.b64decode(header_val + "===")  # tolerate missing pad
+        return json.loads(raw.decode("utf-8"))
+    except Exception:
+        return None
+
+
+def parse_402(
+    path: str,
+    status_code: int,
+    headers: Dict[str, str],
+    body: Union[Dict[str, Any], str, None],
+) -> PaymentRequired:
+    hdrs = {k.lower(): v for k, v in headers.items()}
+    pr_header = hdrs.get("payment-required")
+    parsed_header = _b64json(pr_header) if pr_header else None
+    if isinstance(body, str):
+        try:
+            body_obj: Dict[str, Any] = json.loads(body)
+        except Exception:
+            body_obj = {"raw": body}
+    elif isinstance(body, dict):
+        body_obj = body
+    else:
+        body_obj = {}
+
+    source = parsed_header or body_obj
+    accepts = list(source.get("accepts") or body_obj.get("accepts") or [])
+    hint = catalog.price_of(path)
+    # Prefer extensions.priceUsd or amount/1e6 from preferred accept
+    price = hint
+    for a in accepts:
+        if a.get("network") == "eip155:8453":
+            try:
+                price = int(a.get("amount", 0)) / 1_000_000
+            except Exception:
+                pass
+            break
+    if price is None and accepts:
+        try:
+            price = int(accepts[0].get("amount", 0)) / 1_000_000
+        except Exception:
+            pass
+
+    msg = (
+        f"HTTP 402 Payment Required for {path}"
+        + (f" (~${price} USDC via x402)" if price is not None else "")
+        + f". Pass a payment_handler to ScraplingData, or open {catalog.DOCS_URL}."
+    )
+    return PaymentRequired(
+        status_code=status_code,
+        path=path,
+        body=body_obj,
+        payment_required_header=pr_header,
+        accepts=accepts,
+        price_usd_hint=price,
+        message=msg,
+    )

scrapling_data-0.1.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.5
+Name: scrapling-data
+Version: 0.1.0
+Summary: Lead-magnet SDK for Scrapling Data: free address tools + x402 pay-per-call crypto intel for AI agents (USDC on Base, no API key).
+Project-URL: Homepage, https://scraplingdata.xyz
+Project-URL: Documentation, https://scraplingdata.xyz/docs
+Project-URL: Repository, https://github.com/scraplingdata
+Project-URL: Hugging Face, https://huggingface.co/scraplingdata
+Project-URL: OpenAPI, https://scraplingdata.xyz/openapi.json
+Project-URL: llms.txt, https://scraplingdata.xyz/llms.txt
+Project-URL: x402 manifest, https://scraplingdata.xyz/.well-known/x402
+Project-URL: Issues, https://github.com/scraplingdata/scrapling-data-skill/issues
+Author-email: Scrapling Data <scraplingdata@mail.grokbot.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,base,crypto,defi,mcp,scrapling,usdc,wallet,x402
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# scrapling-data
+
+**Lead-magnet Python SDK** for [Scrapling Data](https://scraplingdata.xyz) — pay-per-call crypto & web intel for AI agents via **x402** (USDC on Base, no API key).
+
+Install once. Get **free** local address tools and free store teasers. When you need the real answer, the same client speaks **HTTP 402 → pay → retry** against the live catalog.
+
+- Site: https://scraplingdata.xyz
+- Docs: https://scraplingdata.xyz/docs
+- GitHub: https://github.com/scraplingdata
+- Hugging Face: https://huggingface.co/scraplingdata
+- MCP: https://scraplingdata.xyz/mcp
+
+> This package is the **public thin SDK**. It does **not** include Scrapling's private scrapers, label builders, or secrets.
+
+## Install
+
+```bash
+pip install scrapling-data
+```
+
+(Until published: `pip install -e /path/to/scrapling-data`)
+
+## 30-second sticky start
+
+```bash
+# Free local checksum + free wallet-label teaser + paid price menu
+scrapling-data check 0x28C6c06298d514Db089934071355E5743bf21d60
+
+# Lookalike / address-poisoning heuristic (local, free)
+scrapling-data check 0x28C6c06298d514Db089934071355E5743bf21d60 \
+  --compare 0x28C6c06298d514Db089934071355E5743bf21d61
+```
+
+```python
+from scrapling_data import ScraplingData, inspect_address, to_checksum_address
+
+print(inspect_address("0x28c6c06298d514db089934071355e5743bf21d60"))
+print(to_checksum_address("0x28c6c06298d514db089934071355e5743bf21d60"))
+
+with ScraplingData() as sd:
+    print(sd.free_crypto_top10())          # free
+    print(sd.free_wallet_label("0x28C6c06298d514Db089934071355E5743bf21d60"))
+    # Paid — raises PaymentRequiredError with accepts[] unless you attach a signer:
+    # sd.counterparty("0x28C6c06298d514Db089934071355E5743bf21d60")
+```
+
+## What's free vs paid
+
+| Layer | What you get | Cost |
+| --- | --- | --- |
+| **Local** | EVM validate, EIP-55 checksum, ENS/Solana detect, lookalike/poison heuristic, chain id hints | Free, offline |
+| **Free API** | `/v1/free/*` teasers (wallet-label sample, hack-tracker headline, top10, yields, 3×/day risk-check, …) | Free (rate-limited) |
+| **Paid API** | Full counterparty, risk-check, hack-tracker, yields, market-pulse, tokenized assets, whales, DD, … | From **$0.0009** USDC via x402 |
+
+### Sticky funnel (by design)
+
+1. `scrapling-data check <addr>` → valid + checksum + free label teaser.
+2. See the **paid menu** with live catalog prices.
+3. Call `ScraplingData(...).counterparty(addr)` (or risk-check / hack-tracker / …).
+4. Without a wallet: clear **402** payload + docs link. With `payment_handler`: auto-retry with `PAYMENT-SIGNATURE`.
+
+## Paying with x402
+
+```python
+from scrapling_data import ScraplingData, PaymentRequiredError
+
+def my_signer(payment):
+    """Return a PAYMENT-SIGNATURE string. Use your own wallet / x402 client.
+    Never put a private key in this library or in source control."""
+    accept = payment.preferred_accept()
+    # ... sign accept with your viem / eth-account / Coinbase AgentKit / x402 SDK ...
+    raise NotImplementedError("wire your signer here")
+
+sd = ScraplingData(payment_handler=my_signer)
+try:
+    print(sd.counterparty("0x28C6c06298d514Db089934071355E5743bf21d60"))
+except PaymentRequiredError as e:
+    print(e.payment.to_dict())  # accepts, amount, payTo, how_to_pay
+```
+
+Also supported: `pass_token=` (day/month pass), `api_key=` (`Bearer sk_scrapling_...`), `trial_code=`.
+
+Day pass **$2** · month pass **$25** · settlement payTo (EVM): `0x72C80C01fD89Bac74f47cf604b61ACd119c9BCdb`.
+
+## Highlight paid routes (catalog hints)
+
+Prices from live `/llms.txt` + OpenAPI (Nov 2026). **402 body is authoritative.**
+
+| Route | USD | Use |
+| --- | ---: | --- |
+| `/v1/lookup/address-poisoning` | 0.0009 | Live Base USDC lookalike flags |
+| `/v1/bundle/market-pulse` | 0.001 | Whole-market pulse |
+| `/v1/wallet-label` | 0.002 | Full label + sources |
+| `/v1/check/counterparty` | 0.004 | safe / caution / block |
+| `/v1/intel/risk-check` | 0.0045 | MALICIOUS…UNKNOWN (3 free/day) |
+| `/v1/wallet/profile` | 0.005 | Who is this wallet? |
+| `/v1/lookup/tokenized-stocks` | 0.005 | Ondo / xStocks |
+| `/v1/lookup/hack-tracker` | 0.03 | Stolen-funds tracker |
+| `/v1/trust/agent` | 0.04 | Agent trust bundle |
+| `/v1/dd/report` | 1.00 | Full due-diligence |
+| `/v1/bundles/stolen-funds/download` | 12 | Pack download (not on passes) |
+
+Full machine list: https://scraplingdata.xyz/llms.txt · https://scraplingdata.xyz/openapi.json
+
+## CLI
+
+```text
+scrapling-data check <address> [--compare 0x...] [--offline] [--json]
+scrapling-data catalog [--max-price 0.01]
+scrapling-data ping
+```
+
+## For agents / MCP
+
+See [`AGENT.md`](./AGENT.md). Remote MCP (same store): `https://scraplingdata.xyz/mcp`.
+
+## License
+
+MIT © Scrapling Data

scrapling_data-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+scrapling_data/__init__.py,sha256=n2gZr1PXI-s-UvavQLncZ0cE4i7TQss4pP6oGONfObQ,1049
+scrapling_data/__main__.py,sha256=HRUOs4hOqMu9Jt_tfRlb3NSIVXO-bnqJR0LY3FAJOJk,62
+scrapling_data/_keccak.py,sha256=RcYmiWGZzewR9FFX0V0XNsmXrKJjGycqTfbxuxpIcc0,2449
+scrapling_data/catalog.py,sha256=e_9mohIQYuLEjItES4nLkD6fW1RD_kfPHQ3I9tDzCJ0,5341
+scrapling_data/cli.py,sha256=jVHCx1OMv0A5ftX_h20NllnW7RsRyfz-0cozI6FVE80,6835
+scrapling_data/client.py,sha256=snlcQtOY4ds9Frjb2vjXzVCfe2ACWKvj3MQ1PokDb7g,9700
+scrapling_data/local.py,sha256=h4dBns7YlLGSrcTbDCVs0Kov-4j0Dpb0XrzZVdyn-6o,9881
+scrapling_data/x402.py,sha256=FktPScAnTKZ36ofx9RntD0oUAOBquMvbjldVpqSs_dY,4432
+scrapling_data-0.1.0.dist-info/METADATA,sha256=InPgciy8fxg1qmd8FYA37gEVAL3WW5W271gu7k-R1Zo,6382
+scrapling_data-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+scrapling_data-0.1.0.dist-info/entry_points.txt,sha256=1XAeUoEdpg5h6EdRhDUVHLA3lRABenbcIsEgcZPjWTo,59
+scrapling_data-0.1.0.dist-info/licenses/LICENSE,sha256=VleBzJFNM4YHe1ugxQJwiCyTnD2tgnhj_6ODkVD03oo,1071
+scrapling_data-0.1.0.dist-info/RECORD,,

scrapling_data-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

scrapling_data-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+scrapling-data = scrapling_data.cli:main

scrapling_data-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Scrapling Data
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.