bor_getCurrentValidators

bor_getCurrentValidators returns the validator set that is currently active in Polygon's Bor consensus layer. On mainnet this is an array of roughly 100–150 validator objects, each describing one staking validator: its sequential ID, its signer address, its voting power (stake weight), and its accum (the proposer-rotation accumulator used to decide who proposes the next block).

This is a Bor-consensus method, not a standard EVM call — it exposes Polygon's proof-of-stake validator state that generic Geth-style endpoints do not provide. Use it for validator-set monitoring, tracking stake distribution, anticipating proposer rotation, or building governance/compliance snapshots.

The validator set rotates once per epoch — an epoch is ~1024 blocks (64 sprints × 16 blocks), about ~36 minutes on Polygon. Between epoch boundaries the set is effectively static, so polling on every block is wasteful. Recommend a client-side cache with a TTL of ~30 minutes. The response payload is light (~10–15 KB for ~120 validators), so the cost is the request count, not the body size.

The bor namespace requires the Pro tier. Calling it on a lower tier returns -32002 tier_insufficient.

This method takes no parameters. Send an empty positional array.

The example above is trimmed to two entries; a live mainnet response contains ~100–150 validator objects in result.

Errors follow the standard JSON-RPC error envelope (code, message, and a data object carrying category, current_tier, required_tier, limit_rps, retry_after_sec, and upgrade_url).

See the shared errors reference for the full error envelope, the complete code list, and retry guidance.

JavaScript (fetch)

const res = await fetch("https://api.triport.io/v1/polygon/rpc", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.TRIPORT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "bor_getCurrentValidators",
    params: [],
  }),
});


const { result: validators } = await res.json();
console.log(`active validators: ${validators.length}`);
console.log(`top stake: ${validators.sort((a, b) => b.power - a.power)[0].signer}`);

TypeScript SDK (@triport/sdk)

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


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


const validators = await client.polygon.rpc<
  Array<{ ID: number; signer: string; power: number; accum: number }>
>("bor_getCurrentValidators");


console.log(`active validators: ${validators.length}`);

Python (triport-sdk)

import os
from triport import Triport


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


validators = client.polygon.rpc("bor_getCurrentValidators")
print(f"active validators: {len(validators)}")
total_power = sum(v["power"] for v in validators)
print(f"total voting power: {total_power}")

• Cache it. The set is epoch-static (~36 min / ~1024 blocks). A ~30-minute client-side cache TTL keeps you well within the Pro-tier RPS cap and avoids needless -32003 rate_limited responses.
• Per-block vs. per-epoch. bor_getCurrentValidators is epoch-scoped. For the live block proposer use bor_getCurrentProposer, and for the full consensus snapshot (validators + recent signers + block context) use bor_getSnapshot.
• accum can be negative. It is a signed rotation accumulator, not a balance — don't treat it as stake. Use power for stake weight.
• Bor-only. This is a Polygon Bor-fork method and has no Ethereum equivalent; it is not part of the standard Geth namespace.