# Crypto Mining Profitability Scanner (`gochujang/crypto-mining-profitability`) Actor

Real-time GPU mining profitability for 46+ PoW coins. Enter your GPU model, power usage, and electricity rate — get daily/monthly net profit after electricity costs. WhatToMine API, no auth required. $0.005/run.

- **URL**: https://apify.com/gochujang/crypto-mining-profitability.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does Crypto Mining Profitability Scanner do?

**Crypto Mining Profitability Scanner** fetches real-time network difficulty, hashrate, and block reward data from WhatToMine for all **GPU-mineable proof-of-work coins**, then calculates your exact **net daily and monthly profit** after electricity costs. Enter your GPU model and electricity rate — the actor automatically looks up the correct hashrate for RTX 4090, RTX 3090, RTX 3080, RTX 3070, RX 7900 XTX, and RX 6800 XT — and returns a ranked list of every mineable coin from most to least profitable, complete with **break-even days**, **annual ROI**, and **miner capitulation risk** signals.

### Why use Crypto Mining Profitability Scanner?

- **Automatic GPU hashrate lookup**: No need to manually enter MH/s figures — just select your GPU model and the actor applies the correct hashrate for each algorithm (Ethash, KawPow, Autolykos2, ProgPow) automatically, giving accurate **GPU mining profitability** estimates in one click.
- **True net profit after electricity**: Every coin shows `net_profit_daily` and `monthly_net_profit` after deducting your actual electricity cost, plus an `electricity_cost_breakeven` field showing the maximum $/kWh rate before mining goes negative.
- **Hardware ROI analysis**: Fields like `hardware_roi_timeline` (break-even days), `annual_roi_pct`, and `profitability_tier` let you evaluate whether your rig makes financial sense at current **crypto mining difficulty** levels.
- **Advanced market signals**: `miner_capitulation_risk_per_coin`, `hash_rate_trend_signal`, `network_difficulty_signal`, `post_halving_stress_level`, and `mining_concentration_risk` give you forward-looking intelligence that simple **mining calculators** omit entirely.
- **Multi-coin coverage in one run**: A single $0.005 flat run returns profitability data for all 46+ GPU-mineable coins simultaneously — no per-coin charges, no pagination, no manual lookups on multiple websites.

### How to use Crypto Mining Profitability Scanner

1. Go to the Apify Store and open the **Crypto Mining Profitability Scanner** actor page.
2. Click **Try for free** to open the actor in Apify Console.
3. Select your `gpuModel` from the supported list (RTX 4090, RTX 3090, RTX 3080, RTX 3070, RX 7900 XTX, RX 6800 XT).
4. Set `electricityKwhRate` to your actual electricity cost in USD/kWh (default $0.12).
5. Optionally set `numGpus` for multi-GPU rigs and `minDailyProfitUsd` to filter out unprofitable coins.
6. Click **Save & Run** and receive ranked results in under 30 seconds.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `gpuModel` | string | `RTX 3080` | GPU model for automatic hashrate lookup (`RTX 4090`, `RTX 3090`, `RTX 3080`, `RTX 3070`, `RX 7900 XTX`, `RX 6800 XT`) |
| `numGpus` | integer | `1` | Number of identical GPUs in your mining rig |
| `gpuPowerWatts` | number | auto | Override power consumption in watts (leave blank to use GPU defaults) |
| `electricityKwhRate` | number | `0.12` | Your electricity cost in USD per kWh |
| `minDailyProfitUsd` | number | `-999` | Hide coins below this net daily profit threshold |
| `sortBy` | string | `net_profit_daily` | Sort order: `net_profit_daily`, `daily_revenue_usd`, or `monthly_net_profit` |

### Output

```json
[
  {
    "rank": 1,
    "coin": "Ergo",
    "algorithm": "Autolykos2",
    "daily_revenue_usd": 4.82,
    "daily_electricity_usd": 0.63,
    "net_profit_daily": 4.19,
    "monthly_net_profit": 125.70,
    "annual_roi_pct": 30.6,
    "break_even_days": 119,
    "electricity_cost_ratio_pct": 13.1,
    "profitability_index": 142,
    "profitability_tier": "high_margin",
    "mining_profitability_tier": "strong_roi",
    "hardware_roi_timeline": "4 months",
    "electricity_cost_breakeven": 0.91,
    "miner_capitulation_risk_per_coin": "low",
    "hash_rate_trend_signal": "stable",
    "network_difficulty_signal": "flat",
    "mining_concentration_risk": "moderate",
    "post_halving_stress_level": "normal",
    "gpu_efficiency_label": "excellent",
    "algorithm_category": "gpu_friendly"
  },
  {
    "rank": 2,
    "coin": "Ravencoin",
    "algorithm": "KawPow",
    "daily_revenue_usd": 3.11,
    "daily_electricity_usd": 0.63,
    "net_profit_daily": 2.48,
    "monthly_net_profit": 74.40,
    "annual_roi_pct": 18.1,
    "break_even_days": 201,
    "electricity_cost_ratio_pct": 20.3,
    "profitability_index": 91,
    "profitability_tier": "moderate_margin",
    "mining_profitability_tier": "moderate_roi",
    "hardware_roi_timeline": "7 months",
    "electricity_cost_breakeven": 0.59,
    "miner_capitulation_risk_per_coin": "medium",
    "hash_rate_trend_signal": "declining",
    "network_difficulty_signal": "falling",
    "mining_concentration_risk": "low",
    "post_halving_stress_level": "normal",
    "gpu_efficiency_label": "good",
    "algorithm_category": "gpu_friendly"
  }
]
```

### Data fields

| Field | Description |
|---|---|
| `rank` | Position in results ranked by chosen sort field |
| `coin` | Coin name (e.g., Ergo, Ravencoin, Flux) |
| `algorithm` | Mining algorithm (Ethash, KawPow, Autolykos2, ProgPow) |
| `daily_revenue_usd` | Gross daily mining revenue at current difficulty (USD) |
| `daily_electricity_usd` | Daily electricity cost based on your $/kWh rate (USD) |
| `net_profit_daily` | Net daily profit after electricity (USD) |
| `monthly_net_profit` | 30-day net profit estimate (USD) |
| `annual_roi_pct` | Annual return on hardware investment (%) |
| `break_even_days` | Days until hardware cost is fully recovered at current profitability |
| `electricity_cost_ratio_pct` | Electricity as percentage of gross revenue |
| `electricity_cost_breakeven` | Maximum $/kWh rate before this coin becomes unprofitable |
| `profitability_index` | WhatToMine profitability index vs. ETH baseline |
| `profitability_tier` | `high_margin` / `moderate_margin` / `thin_margin` / `loss` |
| `mining_profitability_tier` | ROI-based tier: `strong_roi` / `moderate_roi` / `weak_roi` / `negative` |
| `hardware_roi_timeline` | Human-readable break-even estimate (e.g., "4 months") |
| `miner_capitulation_risk_per_coin` | `low` / `medium` / `high` — proximity to production cost floor |
| `hash_rate_trend_signal` | Network hashrate momentum: `growing` / `stable` / `declining` |
| `network_difficulty_signal` | `rising` / `flat` / `falling` |
| `mining_concentration_risk` | Pool concentration risk: `low` / `moderate` / `high` |
| `post_halving_stress_level` | Mining cycle position: `normal` / `stressed` / `critical` |
| `gpu_efficiency_label` | `excellent` / `good` / `fair` / `poor` (MH/W rating) |
| `algorithm_category` | `gpu_friendly` or `asic_dominated` |

A mining market summary record is also returned with `most_profitable_coin_to_mine`, `network_security_trend`, `global_mining_revenue_24h_usd`, `average_breakeven_price`, and `mining_industry_health`.

### Cost estimation

| Scenario | Runs | Cost |
|---|---|---|
| Small (one-off check) | 1 run | **$0.005** |
| Medium (daily profitability scan) | 30 runs/month | **$0.15/month** |
| Large (hourly automated rig management) | 720 runs/month | **$3.60/month** |

Flat $0.005 per run — all 46+ coins are returned in every run regardless of how many pass the profit filter.

### FAQ

**Does the actor support custom GPU hashrates?**
Yes. Set `gpuPowerWatts` to override the default power figure, or — for GPUs not in the supported list — reach out via Apify's support channel. Custom hashrate input per algorithm is on the roadmap.

**Why is my coin not showing up in results?**
Coins dominated by ASICs (SHA-256, Scrypt, X11, Blake2b) are excluded because GPU mining is not competitive on those algorithms. Only GPU-mineable coins where your hashrate is relevant are returned.

**How accurate are the profit estimates?**
Estimates are based on current WhatToMine network data (difficulty, price, block reward) at the time of the run. Actual profitability varies with coin price volatility, pool fees (typically 1–2%), and real-world hardware variance. Always treat these as indicative estimates, not guaranteed returns.

> **Disclaimer**: Mining profitability estimates are based on real-time data from WhatToMine and reflect conditions at the time of the run. Cryptocurrency prices, network difficulty, and block rewards fluctuate continuously. This data is provided for informational purposes only and does not constitute financial or investment advice. Mining cryptocurrencies carries significant financial risk.

Keywords: GPU mining calculator, crypto mining profitability, WhatToMine scraper, mining ROI calculator, hashrate profitability, electricity cost mining, PoW mining calculator, RTX 4090 mining profit, net profit GPU mining, best coin to mine

***

### Related actors

- [Bitcoin Mining Pools](https://apify.com/gochujang/bitcoin-mining-pools) — Bitcoin mining pool hashrate distribution to contextualize mining profitability trends
- [BTC Miner Revenue Tracker](https://apify.com/gochujang/btc-miner-revenue-tracker) — Bitcoin miner revenue from fees and block rewards alongside GPU profitability data
- [Energy Prices Tracker](https://apify.com/gochujang/energy-prices-tracker) — Electricity price trends that directly affect mining profitability calculations

### Feedback

If this actor powers your mining research, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/crypto-mining-profitability#reviews)

# Actor input Schema

## `gpuModel` (type: `string`):

Your GPU model for hashrate lookup.

## `numGpus` (type: `integer`):

How many GPUs in your mining rig.

## `gpuPowerWatts` (type: `integer`):

Override GPU power consumption. Leave blank to use default for selected model.

## `electricityKwhRate` (type: `number`):

Your electricity cost in USD per kWh.

## `minDailyProfitUsd` (type: `number`):

Filter out coins with net daily profit below this threshold. Use -999 to show all.

## `sortBy` (type: `string`):

Sort results by this metric (descending).

## `limit` (type: `integer`):

Maximum number of coins to return.

## `gpuHardwareCostUsd` (type: `number`):

Optional parameter: gpuHardwareCostUsd

## Actor input object example

```json
{
  "gpuModel": "RTX 3080",
  "numGpus": 1,
  "electricityKwhRate": 0.12,
  "minDailyProfitUsd": -999,
  "sortBy": "net_profit_daily",
  "limit": 50
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/crypto-mining-profitability").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/crypto-mining-profitability").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call gochujang/crypto-mining-profitability --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/crypto-mining-profitability"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6Eu6oSoynsU0YK4AL/builds/I7gRXiBKRq8p0GOPL/openapi.json