Batch wallet identity with filters

The batch endpoint assembles the same profile as GET /v1/wallet/{address}/identity for every address in the request, in parallel with a bounded worker pool, and returns them in one response. A filter (see filters) selects addresses: with return: matched (default) only passing profiles are returned, with return: all every profile is returned and carries a matched flag.

Filters are evaluated lazily. Cheap groups (balances, activity, labels) are computed for every address first; names (one contract call per source) and the expensive deployer scan run only for addresses the cheap predicates did not already reject. Groups the filter needs are computed regardless of fields, but they are returned only if fields lists them — so a filter on is_deployer does not bloat the response with contract lists unless asked.

Duplicate addresses (any letter case, surrounding whitespace) are collapsed and counted in meta.deduplicated; malformed addresses land in errors[] with invalid_address and do not fail the batch. A profile that could not be assembled at all (all_chains_unavailable, timeout) is likewise reported in errors[].

Request body

Response fields

All error bodies use the shared envelope (error, message, request_id). See errors.md for the full envelope and per-code fields.

Named token deployers with an ETH balance (JavaScript)

const res = await fetch("https://triport.io/v1/wallet/identity/batch", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.TRIPORT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    addresses,                       // up to 100 per call
    chains: ["eth", "base"],
    fields: ["names", "deployer"],
    filter: {
      all: [
        { has_name: true },
        { is_deployer: true },
        { tokens_created: { gte: 1 } },
        { balance: { chain: "eth", gte: "0.3" } },
      ],
    },
  }),
});
const { results, matched, total, errors } = await res.json();
console.log(`${matched}/${total} matched, ${errors.length} errors`);
for (const r of results) console.log(r.address, r.names[0]?.name, r.deployer.tokens_created);

Streaming a large list in pages of 100 (Python)

import os
import requests


API = "https://triport.io/v1/wallet/identity/batch"
HEADERS = {"Authorization": f"Bearer {os.environ['TRIPORT_API_KEY']}"}


def pages(seq, size=100):
    for i in range(0, len(seq), size):
        yield seq[i:i + size]


with open("addresses.txt") as f:
    addresses = [line.strip() for line in f if line.strip()]


for page in pages(addresses):
    res = requests.post(API, headers=HEADERS, json={
        "addresses": page,
        "chains": ["eth", "base", "bsc"],
        "fields": ["names", "balances", "labels"],
        "filter": {"any": [{"has_name": True}, {"has_label": ["cex", "bridge"]}]},
    }, timeout=120)
    res.raise_for_status()
    body = res.json()
    for r in body["results"]:
        print(r["address"], [n["name"] for n in r.get("names", [])], [l["entity"] for l in r.get("labels", [])])

• Sizing a run: each address costs, per queried network, three <net>_read_rpc tokens for state plus one eth_call per name source on that network, and the deployer scan adds ⌈nonce / 500⌉ calls per network. Six networks and default fields are roughly 25 upstream calls per address; a Business key (250 rps per network) sustains about 10 addresses/s per network — 5 million addresses take several hours per PoP. Run pages concurrently only up to your per-network budgets; the response's meta.cost shows the actual spend.
• Filter first, fields second: put the cheap predicates (balance, active_on, has_label) into the filter and request deployer only in fields where you need the contract list — the scan then runs for the survivors only.
• Partial profiles still match: a network that failed is present as chains.<net>.error; predicates on that network see it as balance 0 / nonce 0. Check errors[] and chains.*.error before treating a non-match as final.
• Related: single-address profile, filter catalog.