Monitoring and analytics for carders: how to build a personal dashboard

[Good Carder]

From a carder to carders. You've hits 100 cards, 10 won, 90 failed. Do you know which BINs work? What time of day is best to carding? Which proxies have the fewest rejections? If you can't answer these questions, you're gambling, not carding.

In this article, I'll show you how to build a monitoring and analytics system that will transform the chaos of rejections into a manageable process. You'll learn how to collect data (Google Sheets + Python), what metrics to track, how to visualize trends (Plotly, Grafana), and build a dashboard to track ROI. No theory — only ready-made solutions that work in 2026.

Part 1: Why Without Analytics You're a Player, Not a Carder​

Most newbies operate on the principle of "hit it, it crashes, and then forget it." They don't remember which BIN worked, which proxy crashed, or what time of day they were successful. This is a recipe for constant losses.

A professional carder keeps a log of every attempt. They know:

• Which BINs give 30% success, and which ones - 5% (and stop buying junk).
• Which proxy providers are stable, and which ones burn out after 10 requests.
• At what time of day are banks less vigilant (most often 2-5 am local time).
• Which payment gateway (Stripe, Adyen, Braintree) gives more passes?

Without a log, you're blind. With a log, you see the system.

Part 2. Data Collection: From Data Hit to Google Sheets​

The first step is to organize your data collection. Don't rely on memory. Every attempt should be included in the table.

2.1 Minimum log fields​

Create a Google Sheets file with columns (or a CSV file that you can then upload):

Field	Example	Description
timestamp	2026-05-25 14:32:11	Attempt time (UTC)
site	shopify.com/example	Target store
bin	414720	The first 6 digits of the card
country_card	US	Country of issuer
proxy_ip	45.67.89.10	IP proxy
proxy_type	residential	residential / datacenter / mobile
proxy_provider	webshare	Provider name
antidetect	dolphin_anty	Antidetector name
profile_id	prof_a1b2c3	Profile ID
http_status	402	HTTP response status
error_code	insufficient_funds	Error code from the gateway
response_time_ms	2350	TTFB in milliseconds
amount_usd	49.99	Check amount
result	fail	success / fail
notes	proxy reused	Comments

2.2 Automatic logging via Python​

Manually filling out a spreadsheet is tedious. It's better to write a script that automatically adds a row to Google Sheets after each hit (or checker).

Here's an example Python script for writing to Google Sheets:

import gspread
from oauth2client.service_account import ServiceAccountCredentials
import datetime

# Configure access to Google Sheets
scope = ['https://spreadsheets.google.com/feeds', 'https://www.googleapis.com/auth/drive']
creds = ServiceAccountCredentials.from_json_keyfile_name('credentials.json', scope)
client = gspread.authorize(creds)

# Open a spreadsheet (by URL or name)
sheet = client.open('Carding Log 2026').sheet1

def log_attempt(data):
row = [
datetime.datetime.utcnow().isoformat(),
data.get('site', ''),
data.get('bin', ''),
data.get('country_card', ''),
data.get('proxy_ip', ''),
data.get('proxy_type', ''),
data.get('proxy_provider', ''),
data.get('antidetect', ''),
data.get('profile_id', ''),
data.get('http_status', ''),
data.get('error_code', ''),
data.get('response_time_ms', ''),
data.get('amount_usd', ''),
data.get('result', ''),
data.get('notes', '')
]
sheet.append_row(row)

# Usage example
log_attempt({
'site': 'shopify.com/example',
'bin': '414720',
'country_card': 'US'
'proxy_ip': '45.67.89.10',
'proxy_type': 'residential',
'proxy_provider': 'webshare',
'antidetect': 'dolphin_anty',
'profile_id': 'prof_001',
'http_status': 402,
'error_code': 'insufficient_funds',
'response_time_ms': 2350,
'amount_usd': 49.99,
'result': 'fail',
'notes': 'first attempt'
})

Where to get credentials.json: Create a project in the Google Cloud Console, enable the Google Sheets API, create a service account, download the JSON key, and share the spreadsheet using the email address of that service account.

2.3. Logging via local CSV (if you don't want the cloud)​

import csv
import datetime

def log_attempt_csv(data, filename='carding_log.csv'):
file_exists = False
try:
with open(filename, 'r'):
file_exists = True
except FileNotFoundError:
pass
   
with open(filename, 'a', newline='') as f:
writer = csv.writer(f)
if not file_exists:
writer.writerow(['timestamp', 'site', 'bin', 'country_card', 'proxy_ip', 'proxy_type', 'proxy_provider', 'antidetect', 'profile_id', 'http_status', 'error_code', 'response_time_ms', 'amount_usd', 'result', 'notes'])
writer.writerow([
datetime.datetime.utcnow().isoformat(),
data.get('site', ''),
data.get('bin', ''),
data.get('country_card', ''),
data.get('proxy_ip', ''),
data.get('proxy_type', ''),
data.get('proxy_provider', ''),
data.get('antidetect', ''),
data.get('profile_id', ''),
data.get('http_status', ''),
data.get('error_code', ''),
data.get('response_time_ms', ''),
data.get('amount_usd', ''),
data.get('result', ''),
data.get('notes', '')
])

2.4. Parsing Logs from the Stripe API (Advanced)​

If you use Stripe for checking, you can automatically download payment data via the API:

import stripe
stripe.api_key = "sk_live_..."

# Get the last 100 PaymentIntents
intents = stripe.PaymentIntent.list(limit=100)

for intent in intents:
# Extract required fields
data = {
'timestamp': datetime.fromtimestamp(intent.created).isoformat(),
'bin': intent.payment_method_details.card.bin,
'country_card': intent.payment_method_details.card.country,
'http_status': 200 if intent.status == 'succeeded' else 402,
'error_code': intent.last_payment_error.get('code') if intent.last_payment_error else None,
'amount_usd': intent.amount / 100,
'result': 'success' if intent.status == 'succeeded' else 'fail'
}
log_attempt(data)

Part 3. Key Metrics for Analysis​

Once you've collected 50-100 records, you can begin analyzing them. Here are the most important metrics.

3.1. Success by BIN​

Group entries by BIN (or by the first 4 digits of the BIN if 6 is too small). Calculate the success rate.

Formula: (number of successes / total number of attempts for this BIN) * 100%.

BINs with a success rate of >20% are in the green zone (buy more).
BINs with a success rate of 5–20% are in the yellow zone (check for a proxy issue).
BINs with a success rate of <5% are in the red zone (don't buy, even if it's cheap).

3.2. Success by proxy provider​

Group by proxy_provider. Compare success rates. If one provider has a 30% success rate and another has 0%, you know which one to work with.

3.3. Success by Time of Day​

Add the column hour = HOUR(timestamp) to the table. Plot a graph of success by hour. Peak activity often occurs between 2 and 5 AM local time (when bank fraud departments are sleeping).

3.4. Payment Gateway Success​

Group by website domain or gateway type (Stripe, Adyen, Braintree, custom). You'll quickly understand which gateways are leaky and which are tough.

3.5. Average response time (response_time_ms)​

Slow responses (>3000 ms) may indicate a poor proxy or network issues. Fast responses (<200 ms) when rejected often mean the card was rejected at the gateway level without a request to the bank.

3.6. ROI (Return on Investment)​

The most important metric. Calculated as (revenue from successful transactions - card, proxy, and anti-detection costs) / expenses * 100%. Maintain a separate expense table.

Part 4. Visualization: From Boring Tables to Lively Charts​

Raw data in a table is good, but charts give you an instant understanding of trends.

4.1. Creating charts in Google Sheets​

Google Sheets has built-in tools: select data → Insert → Chart. Choose the type (linear for time, columnar for BIN comparison). Disadvantage: you need to update it manually.

4.2. Visualization via Python + Plotly​

Plotly is a powerful library for interactive charts.

import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

# Load the log
df = pd.read_csv('carding_log.csv', parse_dates=['timestamp'])

#1. Success by the clock
df['hour'] = df['timestamp'].dt.hour
hourly_success = df.groupby('hour')['result'].apply(lambda x: (x == 'success').mean() * 100).reset_index()
fig1 = px.line(hourly_success, x='hour', y='result', title='Success Rate by Hour of Day')
fig1.show()

#2. Success by BIN (Top 20)
bin_success = df.groupby('bin')['result'].apply(lambda x: (x == 'success').mean() * 100).sort_values(ascending=False).head(20).reset_index()
fig2 = px.bar(bin_success, x='bin', y='result', title='Top 20 BINs by Success Rate')
fig2.show()

# 3. Heatmap: Success by day of week and hour
df['dayofweek'] = df['timestamp'].dt.dayofweek
pivot = df.pivot_table(index='hour', columns='dayofweek', values='result', aggfunc=lambda x: (x == 'success').mean() * 100).fillna(0)
fig3 = px.imshow(pivot, labels=dict(x="Day of Week", y="Hour", color="Success %"), title="Success Rate Heatmap")
fig3.show()

#4. Comparison of proxy providers
proxy_success = df.groupby('proxy_provider')['result'].apply(lambda x: (x == 'success').mean() * 100).reset_index()
fig4 = px.bar(proxy_success, x='proxy_provider', y='result', title='Success Rate by Proxy Provider')
fig4.show()

4.3. Grafana for professional dashboards​

Grafana is a monitoring system that connects to databases (PostgreSQL, MySQL) and generates dashboards in real time.

How to set it up:

1. Install PostgreSQL (or use the free cloud version).
2. Write a script that loads logs into the database.
3. Connect Grafana to the database.
4. Create a dashboard with panels: a success graph over time, a table of top BINs, ROI metrics.

It's more complex than Plotly, but it offers automatic updates and access from any device.

Part 5. Streamlit Dashboard Example (Ready-Made Code)​

Streamlit is a Python framework for building web applications. You can run the dashboard locally or open it in a browser.

The full dashboard code is:

import streamlit as st
import pandas as pd
import plotly.express as px
from datetime import datetime

st.set_page_config(page_title="Carding Analytics Dashboard", layout="wide")
st.title("📊 Carding Dashboard (Attempt Analysis)")

# File Upload
uploaded_file = st.file_uploader("Upload log (CSV)", type=["csv"])
if uploaded_file is not None:
df = pd.read_csv(uploaded_file, parse_dates=['timestamp'])

# Base Metrics
total_attempts = len(df)
success_attempts = len(df[df['result'] == 'success'])
success_rate = success_attempts / total_attempts * 100 if total_attempts > 0 else 0

col1, col2, col3 = st.columns(3)
col1.metric("Total Attempts", total_attempts)
col2.metric("Successful", success_attempts)
col3.metric("Success Rate %", f"{success_rate:.1f}%")

# Time Plot
df['date'] = df['timestamp'].dt.date
daily = df.groupby('date')['result'].apply(lambda x: (x == 'success').mean() * 100).reset_index()
fig_time = px.line(daily, x='date', y='result', title="Success Rate by Day")
st.plotly_chart(fig_time, use_container_width=True)

# Top 10 BIN
bin_success = df.groupby('bin')['result'].apply(lambda x: (x == 'success').mean() * 100).sort_values(ascending=False).head(10).reset_index()
fig_bin = px.bar(bin_success, x='bin', y='result', title="Top 10 BIN by Success")
st.plotly_chart(fig_bin, use_container_width=True)

# Success by Proxy Provider
proxy_success = df.groupby('proxy_provider')['result'].apply(lambda x: (x == 'success').mean() * 100).reset_index()
fig_proxy = px.bar(proxy_success, x='proxy_provider', y='result', title="Success by proxy provider")
st.plotly_chart(fig_proxy, use_container_width=True)

# Table with the last 20 attempts
st.subheader("Last 20 attempts")
st.dataframe(df.tail(20)[['timestamp', 'bin', 'proxy_provider', 'error_code', 'amount_usd', 'result']])

else:
st.info("Upload a CSV file with the attempt log")

How to run:

pip install streamlit pandas plotly
streamlit run dashboard.py

The dashboard will open in your browser. You'll be able to upload a CSV file and see real-time analytics.

Part 6. OPSEC for Analytics​

1. Don't store logs in plaintext. Encrypt CSV files (Veracrypt, AES-256) or use encrypted cloud services (CryptDrive).
2. Don't use your personal Google account for Google Sheets. Create a separate account using Tor or a VPN. Don't link your phone number to it.
3. Regularly purge old records. Don't keep logs longer than 3-6 months. They're evidence.
4. Don't publish dashboard screenshots, even anonymously. Carders can be identified by their metrics and style.
5. Use a separate virtual machine for analytics. Don't mix it with production scripts.

Part 7. Carder's Summary​

Analytics isn't a luxury, it's a necessity. Without it, you can't scale, optimize costs, or survive. Start small: Google Sheets + manual entry. After 50 attempts, switch to automatic logging via Python. After another 100 attempts, implement a dashboard in Streamlit or Grafana.

Key metrics: success by BIN, proxy, time of day, and gateway. ROI is the king of all metrics. If ROI is negative, change card providers, proxies, or strategy.

Logging is your black box. Analyze it every week, and success will no longer be a fluke.

A quick one-line reminder:
"Logging isn't bureaucracy, it's a weapon. Buy a BIN with a 30% success rate, ignore one with 5%. Throw away a proxy provider with 0%. 2–5 AM is key carding time. Charts in Plotly, a dashboard in Streamlit, and log encryption are a must. Without analytics, you're not a carder, you're a gambling addict."