Get aggregated EL peer-graph snapshot

This endpoint returns a snapshot of the observed execution-layer peer graph: a list of directed edges between EL hosts, each carrying the remote client identification, the measured link latency, and the peering direction. Use it to visualize network topology, detect clustering or partitions, and correlate client diversity with connectivity across the hosts Triport observes.

The data is derived intelligence aggregated across many hosts, so it is gated to the enterprise tier. For the neighbor list of a single host, use the companion endpoint GET /v1/eth/intel/peer-graph/host/{host}.

The optional depth parameter controls how many peering hops are traversed outward from the observed seed set (1–3, default 1). Higher depths return more edges and take longer to compute.

Query parameters

Response fields

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

JavaScript (fetch)

const res = await fetch(
  "https://api.triport.io/v1/eth/intel/peer-graph?depth=2",
  {
    headers: {
      Authorization: `Bearer ${process.env.TRIPORT_API_KEY}`,
      "Content-Type": "application/json",
    },
  }
);


if (!res.ok) {
  const err = await res.json();
  throw new Error(`${res.status} ${err.error}: ${err.message}`);
}


const { observed_at, edges } = await res.json();
console.log(`snapshot @ ${observed_at} — ${edges.length} edges`);

TypeScript SDK (@triport/sdk)

import { TriportClient } from "@triport/sdk";


const client = new TriportClient({ apiKey: process.env.TRIPORT_API_KEY! });


const graph = await client.eth.intel.peerGraph({ depth: 2 });
for (const edge of graph.edges) {
  console.log(`${edge.from_host} -> ${edge.to_host} (${edge.direction}, ${edge.latency_ms} ms)`);
}

Python (triport-sdk)

import os
from triport import TriportClient


client = TriportClient(api_key=os.environ["TRIPORT_API_KEY"])


graph = client.eth.intel.peer_graph(depth=2)
print(f"snapshot @ {graph.observed_at} — {len(graph.edges)} edges")
for edge in graph.edges:
    print(f"{edge.from_host} -> {edge.to_host} ({edge.direction}, {edge.latency_ms} ms)")

• Depth trade-off: depth=1 (default) returns only the directly observed peering edges; depth=2–3 walk further across the graph and return progressively larger result sets at higher compute cost.
• Direction semantics: inbound and outbound are relative to from_host; bidirectional indicates the peering was observed in both directions.
• Related: to retrieve the neighbor list (with enode and per-peer client/latency/direction) for a single host, use GET /v1/eth/intel/peer-graph/host/{host}.