To get a breakdown of your earned stake rewards by epoch on the Sui Network, you'll likely need to rely on the Sui network's data directly, as platforms like Suivision and Suiscan might not offer this detailed breakdown. Here are a few potential ways to access epoch-based reward information:

1. Sui Blockchain Data API

• Sui provides an API that can be queried to fetch historical data, including staking rewards. You can use this to track rewards earned per epoch by querying specific staking data.
• Check the Sui JSON-RPC or the Sui Explorer API for reward-related endpoints (if available).
• Example Query (hypothetical): Look for endpoints that provide staking rewards per validator, or rewards per epoch. You may need to filter the data by your address and epoch.

2. Sui CLI for Staking Data

The Sui CLI may provide detailed staking information including staking rewards. You can use the CLI to query your staking balance, rewards, and epoch details.

sui client query --address <your-address> --staking-rewards

This would return staking-related details, but you may need to aggregate the data manually or through scripting to break it down by epoch.

3. Custom Scripts or Bots

If you are familiar with coding, you could write a script (in Python, for example) to aggregate reward data from Sui APIs or a blockchain explorer like Suiscan. This script could fetch staking rewards by epoch and give you a detailed breakdown.

Steps for Custom Script:

• Use the Sui SDK or any available Sui APIs to retrieve staking rewards data.
• Filter by epoch and aggregate the rewards for each epoch.
• Store the results in a format suitable for tax reporting (e.g., CSV, JSON).

4. Third-Party Data Providers

If Suivision and Suiscan don't provide this feature, you might want to check for other third-party platforms or Sui ecosystem tools. Some platforms might offer more granular data, such as block explorers or staking platforms that provide detailed historical reward information.

5. Validator Node API

Validators may also expose staking rewards data for their delegators by epoch. Some validator nodes offer dashboards or APIs where you can query rewards for specific delegations, including historical rewards by epoch.

Conclusion:

If Suivision and Suiscan don't offer the granular breakdown by epoch, you'll either need to use Sui’s direct APIs or CLI, or write a custom script to extract and process this data. Make sure to keep track of this data over time, as it can be useful for tax submissions and auditing.

To get a detailed breakdown of earned stake rewards by epoch, you can query Sui's RPC endpoint suix_getStakes with your validator or staking address, which returns per-epoch reward data. Alternatively, use Sui Explorer's API (https://explorer.sui.io/) or third-party tools like SuiVision Analytics to extract historical reward distributions. For programmatic access, the Sui TypeScript SDK (@mysten/sui.js) can parse this data by filtering the stakeStatus field in the response. If tax reporting is the goal, consider exporting the raw JSON data and processing it with a script to match your accounting needs.

To get a detailed breakdown of earned stake rewards by epoch on the Sui network, you're right that platforms like Suivision and Suiscan typically show only the total rewards accumulated. Unfortunately, this kind of detailed information is not always readily available through public platforms. However, there are a few ways you can approach this:

1. Check Sui's Validator Dashboard or APIs

Sui has a validator dashboard and public APIs that may provide more detailed information on staking rewards, including epoch-based breakdowns. Some Sui validators expose APIs that allow you to query data like rewards per epoch. You might need to use a Sui Node or access Sui APIs directly to get this data.

• Steps to access rewards data:

  • You can check for any available API endpoints that provide epoch-specific reward details from validators or nodes.
  • Access the Sui Explorer or validator-specific platforms, which might expose additional details through their APIs.

2. Using the Sui CLI (Command Line Interface)

The Sui CLI offers tools to interact with the blockchain, and it can provide more detailed insights into staking rewards. You can use the CLI to fetch details on epoch rewards if available.

• Command: You could use the sui CLI to query staking information. Although it doesn't offer a direct command for epoch rewards, you can pull your staking transaction history or check for staking events linked to each epoch.

Here's an example of how you might get staking-related data:

sui client query --gas-budget 10000 --query-type stake

This won't give a detailed breakdown by epoch directly, but with some filtering and scripting, you could pull the necessary data over time and group it by epoch.

3. Use Blockchain Analytics Tools with Epoch Breakdown Features

Some advanced blockchain analytics tools, like Nansen or Dune Analytics, may allow you to extract more detailed historical reward data. While these platforms may not support Sui by default, you could check if they offer any custom analytics or queries for Sui, especially if you're dealing with large amounts of staking data for tax purposes.

4. Manual Breakdown via Transaction History

• Method: You can manually inspect the rewards by looking at your staking transactions and checking for reward issuance linked to specific epochs.

  • For each staking transaction, check the timestamp and correlate it with epoch transitions.
  • Reward data may be tied to these transactions and epoch numbers, and by exporting them (from Sui Explorer or other explorers), you can manually calculate rewards earned in each epoch.

5. Contact Your Validator

Some Sui validators or staking platforms may offer detailed reports or can provide custom queries regarding rewards earned by epoch, especially if you have a significant stake.

Summary:

Currently, Suiscan and Suivision don’t offer a direct epoch-based breakdown of rewards, but you can achieve this through:

• Accessing Sui node APIs for detailed transaction data, including epoch-specific rewards.
• Using the Sui CLI for querying staking data.
• Blockchain analytics platforms like Nansen or Dune for customized reporting.
• Manually correlating staking transactions with epoch transitions.
• Reaching out to your validator for more tailored reports.

If you need detailed records for tax reporting, your best bet may be custom querying via the Sui APIs or reaching out to Sui-specific data providers.

Use Sui CLI or Node RPC to fetch per-epoch rewards:

1. CLI Command:

   sui client staked-sui --address YOUR_ADDRESS  
   

   Shows stake details including epoch breakdowns.

2. RPC Query:
   Call suix_getStakes with your address to get structured reward data.

Alternative:

• Export transaction history from explorers (filter by StakeReward events).

Note: Tax tools like Koinly may auto-calculate this if you sync your wallet.

(Rewards are epoch-based but often aggregated in UIs—raw data is available via API.)

Sui block explorers (Suivision, Suiscan) currently show total staking rewards but not per-epoch breakdowns.

To get epoch-by-epoch rewards:

1. Use the Sui API (sui_getStakingRewards) with a custom script:

   curl -X POST https://fullnode.mainnet.sui.io \
     -H "Content-Type: application/json" \
     -d '{
       "jsonrpc": "2.0",
       "method": "sui_getStakingRewards",
       "id": 1,
       "params": ["<your_address>"]
     }'
   

   This returns rewards grouped by epoch.

2. Parse the response: Each entry includes epoch and amount, enabling per-epoch tracking for tax reporting.

Alternatively, use the Sui TypeScript SDK:

const rewards = await suiClient.getStakingRewards({ owner: address });
// Returns array of { epoch: number, amount: bigint }

This data is on-chain and immutable—build a script to export it to CSV. No third-party tool provides this natively yet.

Use the Sui RPC API (suix_getStakes) to fetch per-epoch rewards.

1. Query via CLI

sui client call \
  --function get_stakes \
  --package 0x3 \
  --module sui_system \
  --args 0xYOUR_STAKED_SUI_ID \
  --gas-budget 10000000

2. TypeScript Example

import { SuiClient } from '@mysten/sui.js/client';

const client = new SuiClient({ url: 'https://fullnode.mainnet.sui.io' });
const stakes = await client.getStakes({ owner: '0xYOUR_ADDRESS' });

// Extract rewards by epoch
stakes.forEach((stake) => {
  stake.stakes.forEach((stakedSui) => {
    console.log('Epoch:', stakedSui.requestEpoch);
    console.log('Rewards:', stakedSui.estimatedReward);
  });
});

Key Notes

• requestEpoch: Epoch when stake was active.
• estimatedReward: Rewards earned in that epoch.
• Tax Tip: Sum rewards per epoch from the output.

Method 1: Using the Sui CLI

# 1. First, get your staked SUI object IDs
sui client objects --json --query '{"matchAll": [{"StructType": "0x3::staking_pool::StakedSui"}]}' | jq '.[].objectId'

# 2. Fetch rewards per epoch for each staked object
sui client call --package 0x3 --module staking_pool --function get_stakes \
  --args <STAKED_SUI_OBJECT_ID> --json | jq '.effects.events[] | select(.stakingPoolEvent)'

This returns reward amounts with epoch numbers.

Method 2: Programmatic (TypeScript)

import { SuiClient } from '@mysten/sui.js/client';

const client = new SuiClient({ url: 'https://fullnode.mainnet.sui.io' });

async function getEpochRewards(stakedSuiId: string) {
  const { data } = await client.queryEvents({
    query: { 
      MoveEventType: '0x3::staking_pool::StakingRewardsDistributedEvent' 
    },
    cursor: null,
    limit: 100
  });
  return data.filter(event => event.parsedJson.staked_sui_id === stakedSuiId);
}

Method 3: Using SuiVision (Advanced View)

1. Go to SuiVision
2. Connect your wallet
3. Navigate to "Staking" → "History"
4. Click "Raw Data" to see epoch-level details

Method 4: Direct RPC Call

curl -X POST https://fullnode.mainnet.sui.io \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "suix_queryEvents",
    "params": [{
      "MoveEventType": "0x3::staking_pool::StakingRewardsDistributedEvent"
    }, null, 100, false],
    "id": 1
  }' | jq '.result.data[] | select(.parsedJson.staked_sui_id == "<YOUR_STAKED_OBJECT_ID>")'

To get a breakdown of earned stake rewards by epoch, query the Sui RPC endpoint sui_getEvents filtered by the StakeReward event type and your staker address. The StakeReward events contain the epoch number and reward amount for each distribution. Since rewards are only disbursed upon unstaking, you must parse historical events from the 0x3::sui_system::StakeReward event type and group them by epoch. Use the Sui TypeScript SDK to automate this retrieval and analysis. Block explorers currently do not provide per-epoch breakdowns, so manual event processing is required.

Most explorers (Suivision, Suiscan) only show total rewards, not per-epoch.

Options:

• Manual Tracking Log your stake amount at the start & end of each epoch → calculate reward = end - start.

• Use RPC or Indexer Advanced option. Query sui_getStakes, sui_getEpochs, or build a custom indexer to track changes.

• Custom Script (Recommended) I can help you write a Python script to fetch rewards per epoch and export to CSV.

You currently cannot retrieve per-epoch staking rewards directly through a built‑in RPC or explorer like Suivision or Suiscan—those only show cumulative rewards. The RPC suix_getStakes and suix_getStakesByIds let you fetch each stake’s stakeRequestEpoch, stakeActiveEpoch, principal and estimatedReward—but they don’t break down rewards by epoch (QuickNode).

To get a detailed breakdown per epoch, you’ll need to implement your own indexing logic:

Start by calling suix_getStakes to get your stake IDs and basics. Then reconstruct each epoch’s earned rewards by comparing stake balances between epochs or replaying every epoch’s reward distribution using the known growth of stake subsidies and pool rewards.

You can also use the GraphQL API to query the Epoch.totalStakeRewards field to see how much total rewards were distributed network‑wide during each epoch (Sui Documentation).

By building an indexer that reads new checkpoints or events each epoch, tracks your stake’s active amount, and correlates that with the epoch’s subsidy share, you can compile a per-epoch reward breakdown suitable for tax reporting or auditing.

In short: there’s no standard RPC for per-epoch rewards, so you’ll need to compute it yourself via stake tracking and epoch metadata. Let me know if you’d like help designing a Rust or TS indexer to calculate it.

Unfortunately, at the moment, a breakdown of stake rewards by each epoch cannot be viewed. Сurrent platforms only provide the total rewards earned to-date without detailing the distribution across different epochs.