# Find wallets connected by funding

> Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils.

Source: https://docs.crius.sh/guides/find-connected-wallets/ · Updated 2026-10-28

Short answer

Call `GET /v1/robinhood/wallet/{address}/connections` (Starter plan, 10 credits). It returns `funded_by` and `funded` (ETH funding in and out, with `eth`, `txs`, `first_block`, `label`, `is_dev`), `transfers` (token transfers with other wallets), `shared_funder_with` (wallets with the same funder), `linked_devs` and a `cluster`.

[GET `/wallet/{address}/connections`](https://docs.crius.sh/reference/wallets/wallet-connections/) [GET `/token/{address}/bubblemap`](https://docs.crius.sh/reference/wallet-graph/bubble-map/) [GET `/dev/{address}`](https://docs.crius.sh/reference/wallets/developer-profile/)

Wallets are connected when money or tokens moved between them: one funded the other with ETH, they sent each other tokens, or the same wallet funded both. On Robinhood Chain, as on any chain, one person can run many wallets, and funding is the trail they leave. Crius builds that graph from every ETH transfer (including internal transfers inside contract calls) and every token transfer, and leaves out exchanges, bridges, pools and other infrastructure that would link strangers.

## Get a wallet’s connections

Example [Starter plan · 10 credits](https://docs.crius.sh/reference/wallets/wallet-connections/)

### CHARGE's creator: funded by a bridge, linked to no other dev

Who funded the wallet that launched Charge AI (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca), and is it linked to other wallets or devs?

GET/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections?limit=3

 

**cURL**

```bash
curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections?limit=3" \
  -H "x-api-key: $CRIUS_API_KEY"
```

**JavaScript**

```js
const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections?limit=3", {
  headers: { "x-api-key": process.env.CRIUS_API_KEY },
});
const { data, meta } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections?limit=3",
    headers={"x-api-key": os.environ["CRIUS_API_KEY"]},
)
body = r.json()
print(body["data"])
```

**Real response 200 Captured Oct 28, 2026 · 82 lines (arrays trimmed)**

```json
{
  "data": {
    "cluster": {
      "funder": "0xd782268f600403843484b70710daee6846fc0db8",
      "id": "f_359981",
      "wallets": 1
    },
    "funded": [
      {
        "address": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e",
        "eth": 0.0005,
        "first_block": 88385886,
        "is_dev": false,
        "label": "pons_v2_launch_factory",
        "txs": 1
      },
      {
        "address": "0xbcb09304eb37d79aada84e23710158e48fb15a3d",
        "eth": 0.11,
        "first_block": 89257687,
        "is_dev": false,
        "label": null,
        "txs": 2
      },
      {
        "address": "0x0cfbf98d825035fc049d9914b644d7887de27d6c",
        "eth": 0.01,
        "first_block": 90076749,
        "is_dev": false,
        "label": null,
        "txs": 1
      }
    ],
    "funded_by": [
      {
        "address": "0xd782268f600403843484b70710daee6846fc0db8",
        "eth": 0.008148386337868892,
        "first_block": 87601233,
        "is_dev": false,
        "label": "bridge:Relay solver",
        "txs": 1
      }
    ],
    "linked_devs": [],
    "note": "ETH funding = top-level ETH transfers + internal (contract) transfers from call traces; swap / launchpad payouts are not funding",
    "scope": "all_history",
    "shared_funder_with": [],
    "transfers": [
      {
        "address": "0xfbb464318e8c283a2bf186b6bd6420143338e1c8",
        "count": 2,
        "direction": "in",
        "is_dev": false,
        "tokens": 2
      },
      {
        "address": "0xbfd9bf98dc34cf4696ee73c781c3039a14ce5915",
        "count": 2,
        "direction": "out",
        "is_dev": false,
        "tokens": 2
      },
      {
        "address": "0x0cfbe3b71266a6ec456c0faaf9805730c6a67d6c",
        "count": 1,
        "direction": "out",
        "is_dev": false,
        "tokens": 1
      }
    ],
    "wallet": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca"
  },
  "meta": {
    "block": 100406869,
    "block_age_ms": 932,
    "block_ts": 1793225085000,
    "chain": "robinhood",
    "finalized_block": 100397649,
    "lag_ms": 88,
    "safe_block": 100401329
  }
}
```

What this tells you

-   `funded_by` has one entry: `0xd782268f600403843484b70710daee6846fc0db8`, labeled `bridge:Relay solver`, which sent 0.008148386337868892 ETH in block 87601233. The wallet’s first ETH came over a bridge.
-   `cluster.funder` is that solver and `cluster.wallets: 1`, with `shared_funder_with: []`: a bridge funds thousands of people, so it links this wallet to no one.
-   `funded` starts with `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e`, labeled `pons_v2_launch_factory`: 0.0005 ETH in block 88385886, the block CHARGE was created in. That’s the launch itself.
-   The wallet also funded `0xbcb09304eb37d79aada84e23710158e48fb15a3d` (0.11 ETH over 2 transactions) and `0x0cfbf98d825035fc049d9914b644d7887de27d6c` (0.01 ETH). All have `is_dev: false`, and `linked_devs` is empty: none of its connections launched a token.
-   Look at `transfers`: `0x0cfbe3b71266a6ec456c0faaf9805730c6a67d6c` (one token transfer, `direction: "out"`) has the same first four and last four characters as `0x0cfbf98d825035fc049d9914b644d7887de27d6c`, which the wallet really funded. That’s the pattern of address poisoning: a lookalike address planted in a wallet’s history so the owner copies it by mistake. Compare full addresses.
-   `scope: "all_history"`: for a wallet, the whole history is searched.

[Wallet connections reference](https://docs.crius.sh/reference/wallets/wallet-connections/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20creator%3A%20funded%20by%20a%20bridge%2C%20linked%20to%20no%20other%20dev&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-connected-wallets%2F%23creator-connections%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fwallet%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%2Fconnections%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A)

## What the fields mean

| Field | Meaning |
| --- | --- |
| `funded_by[]` | Wallets that sent this one ETH, earliest first: `address`, total `eth`, `txs`, `first_block`, `label`, `is_dev`. |
| `funded[]` | Wallets this one sent ETH to, same fields. |
| `transfers[]` | Wallets it exchanged tokens with: `direction` (`in`, `out` or `both`), `count` (transfers), `tokens` (distinct tokens), `is_dev`. |
| `shared_funder_with[]` | Other wallets funded by this wallet's funders. Funders that paid more than 500 wallets (exchanges, bridges, faucets) are skipped. |
| `linked_devs[]` | Token creators among its funders, funded wallets and transfer counterparties. |
| `cluster` | The group formed around its first funder: `id`, `funder`, `wallets` (this wallet plus the others that funder paid). |
| `is_dev` | `true` when that address created a launchpad token. |
| `label` | Known name of the address: an exchange, a bridge, a launchpad contract. |
| `scope` | `all_history` for wallets; busy contracts are searched over the last 30 days. |
| `note` | What counts as funding: top-level and internal ETH transfers; swap and launchpad payouts don't count. |

`limit` sets how many entries each list returns (default 25, up to 200).

## Reading the graph

-   **Alt wallets.** A wallet funded by another non-exchange wallet shortly before it bought a token is the strongest link. Check `funded_by` first.
-   **Sybils and farms.** Many buyers of a token in each other’s `shared_funder_with` usually means one operator. For a whole token at once, the [bubble map](https://docs.crius.sh/guides/read-a-bubble-map/) draws these links between its top holders.
-   **Dev links.** Any address in `linked_devs` launched a token. A buyer funded by the dev is tagged `dev_linked` on token endpoints ([wallet tags](https://docs.crius.sh/concepts/attribution/#wallet-tags)); see [launch risk](https://docs.crius.sh/concepts/launch-risk/).
-   **Lookalikes.** Transfers with an address that mimics one the wallet really uses are poisoning attempts, not real links.

## Use it in your app

1.  **Get a Starter key.** `/connections` needs the Starter plan and costs 10 credits per call.
    
2.  **Start from a wallet that matters**: a token’s dev, a top holder, a copy-trading candidate. Call `/connections` and flag any `linked_devs` or non-exchange `funded_by`.
    
3.  **Follow one hop at a time.** Call `/connections` on the funder or on wallets in `shared_funder_with` to grow the cluster. Stop at labeled addresses (exchanges, bridges, launchpads): they connect everyone.
    
4.  **Cache by wallet.** Funding history only grows; refresh a wallet’s connections when it becomes relevant again, not on every page view.
    

```js
// Flag a wallet that is linked to a token creator or funded by a non-labeled wallet.
const wallet = "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca";
const res = await fetch(`https://api.crius.sh/v1/robinhood/wallet/${wallet}/connections`, {
  headers: { "x-api-key": process.env.CRIUS_API_KEY },
});
const { data } = await res.json();

const privateFunders = data.funded_by.filter((f) => f.label === null);
if (data.linked_devs.length) console.warn("linked to token creators:", data.linked_devs);
if (privateFunders.length) console.warn("funded by wallets:", privateFunders.map((f) => `${f.address} (${f.eth} ETH)`));
console.log(`${data.shared_funder_with.length} wallets share a funder; cluster ${data.cluster?.id} has ${data.cluster?.wallets}`);
```

## Frequently asked questions

**How do I find wallets connected to a wallet on Robinhood Chain?**

Call `/v1/robinhood/wallet/{address}/connections`. `funded_by` lists who sent it ETH, `funded` who it sent ETH to, `transfers` the wallets it exchanged tokens with, and `shared_funder_with` the other wallets its funders paid. Any of those that created a launchpad token also appears in `linked_devs`.

**Why doesn't an exchange or a bridge link my wallet to others?**

An exchange hot wallet or a bridge solver funds thousands of unrelated people. Funders that paid more than 500 wallets are skipped when looking for wallets that share a funder, so a withdrawal from an exchange or a Relay bridge payout never makes two strangers look related.

**Does buying a token from a pool count as a connection?**

No. Token transfers with pools, routers, lockers, launchpads and other known contracts are trading, not links between wallets, and are left out of `transfers`. ETH received from swaps or launchpad payouts isn't counted as funding either (`note` in the response says so).

**How do I find a developer's other wallets?**

Call `/connections` on the dev wallet and read `linked_devs`, `funded` and `shared_funder_with`: a dev who funds a fresh wallet for each launch shows up there. Then check each address with [`/dev/{address}`](https://docs.crius.sh/guides/check-developer-history/) for its own launches.

**Which plan does wallet connections need?**

The Starter plan or higher, 10 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/).

## Related

[Guide **Developer history** Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling. Read](https://docs.crius.sh/guides/check-developer-history/) [Guide **Read a bubble map** Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters. Read](https://docs.crius.sh/guides/read-a-bubble-map/) [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Concept **Launch risk** How Crius spots insider control of a Robinhood Chain token with a clean contract (snipers, wallet farms, uniform holders, LP control) and the thresholds it uses. Read](https://docs.crius.sh/concepts/launch-risk/) [API reference **Wallet connections API** Wallets connected to this one through funding and transfers: who funded it, who it funded, and wallets sharing a funder. Read](https://docs.crius.sh/reference/wallets/wallet-connections/)