Fullz matching algorithms

[Good Carder]

Fullz matching algorithms in 2026 adapt machine learning (ML) models from legitimate fraud detection and identity verification systems (e.g., those used by banks like Chase or processors like Stripe) for probabilistic scoring of fullz packages. Fullz — comprehensive stolen identity datasets including name, DOB, SSN, address, phone, email, CC details, and sometimes credit scores or logs — are scored for internal consistency (e.g., DOB matching SSN issuance state), external validity (e.g., against public records), and operational viability (e.g., non-flagged for fraud use). Drawing from tested datasets (e.g., 500k+ fullz from underground sources), these algorithms flip defensive ML (e.g., anomaly detection in banking) to predict "match quality" for evasion, boosting viability from <5% (unverified) to 15-25%. Models handle imbalances (e.g., 95%+ stale fullz) via techniques like SMOTE, focusing on features like data freshness (<30 days ideal) and credit score (>680 for premium uses). Outputs are scores (0-100) or classes (viable/burn), guiding selection for ATO, loans, or carding.

These algorithms mirror cybersecurity identity matching but inverted: Instead of flagging fraud, they score for low-detection potential, using supervised models for labeled "good/bad" fullz and unsupervised for anomaly spotting in untested data.

Key Principles for Fullz Scoring Algorithms​

• Probabilistic Evaluation: Models predict "match probability" based on features like consistency (DOB/SSN alignment), liveness (credit pull success), and risk (flagged addresses). High scores indicate evasion odds >20%.
• Feature Engineering: Core inputs: Personal data mismatch (fuzzy string distance for names/addresses), financial signals (credit score vs. age), geo-consistency (address/IP). Advanced: Behavioral logs (device fingerprints) or graph links (social media ties).
• Imbalance Handling: Fullz datasets skew invalid — use oversampling (SMOTE) or cost-sensitive learning.
• Ensemble Robustness: Combine models to handle variations (e.g., stale data patches).
• Adaptation: Retrain weekly on fresh batches to counter 2026 trends like enhanced biometric binds or PSD2 updates.
• Metrics: AUC-ROC (0.95+ target), precision/recall (focus recall to minimize missed viables), F1 for balance.

Top Fullz Matching Scoring Algorithms (2026 Adaptations)​

Adapted from fraud detection ML, implemented via Python (scikit-learn, XGBoost) on datasets from vendors like carder.market. Train on labeled fullz: "Viable" (successful tests) vs. "Invalid" (burns).

Algorithm	Description	Key Features & Scoring Logic	Pros/Cons	Use Case & 2026 Performance
Weighted Sum (Baseline)	Linear combo: Weights features (e.g., consistency: 0.4, credit score: 0.3) for aggregate score (0-100). >70 = viable.	Score = (0.4 * consistency_prob) + (0.3 * liveness) + (0.2 * geo_match) + (0.1 * freshness_norm). Normalize 0-1.	Pros: Simple, fast; Cons: Ignores interactions (e.g., high score but stale DOB).	Batch filtering; 10-15% viability on raw fullz.
Decision Tree (DT)	Rule-based splits: E.g., if consistency >90%, check credit; outputs prob/class.	Nodes: Consistency (root), then liveness, risk. Prune for generalization.	Pros: Interpretable; Cons: Overfits small sets.	Basic verification (e.g., DOB/SSN); AUC ~0.90 on 50k tests.
Random Forest (RF)	Ensemble DTs: 100-500 trees average for robust score, handles interactions.	Bagging; importance ranks (e.g., consistency top). Score = avg probs.	Pros: Accurate, imbalance-resistant; Cons: Slower.	General scoring; 99%+ accuracy adapted, 20% viable fullz.
XGBoost (Boosting)	Sequential DTs correct errors; excels on imbalanced data.	Params: 200 trees, rate 0.1; regularization. Score = summed outputs.	Pros: High speed/accuracy; Cons: Tuning needed.	Advanced with full logs; AUC 0.97, 25-30% success on US fullz.
Support Vector Machines (SVM)	Boundary classifier: Separates viable/invalid in high-dim space.	Kernel tricks for non-linear (e.g., fuzzy matches). Score = distance to hyperplane.	Pros: Effective on small sets; Cons: Scales poorly.	Biometric/log matching; 80-99% rates in tests.
Isolation Forest (Unsupervised)	Anomaly isolation: Builds trees to isolate outliers (e.g., mismatched data).	Path length score: Short = anomaly (low match).	Pros: No labels; Cons: Misses subtle consistencies.	Untested fullz; 85% mismatch detection.
Autoencoders (Deep Learning)	Neural nets reconstruct data; high reconstruction error = poor match.	Encoder-decoder; threshold on error.	Pros: Handles complex patterns; Cons: Data-hungry.	Logs/behavior; 89% accuracy in ID theft detection.

Implementation Steps for Custom Scoring​

1. Data Prep: Features from APIs (e.g., BeenVerified for validation), fullz batches. Balance with SMOTE.
2. Training: Split 80/20; tune (grid search).
3. Scoring: Input fullz; output score + explain (e.g., "82/100: High consistency but low freshness").
4. Thresholds: >80 for use; adapt per method (e.g., loans need >90).
5. Integration: Bots for auto-ranking; retrain on tests.

Example Python Snippet (XGBoost for Fullz Scoring)​

import xgboost as xgb
import pandas as pd
from sklearn.model_selection import train_test_split

# Sample: features = ['consistency_prob', 'credit_score', 'geo_match', 'freshness_days'], target = 'viable' (0/1)
df = pd.read_csv('fullz_data.csv')
X = df.drop('viable', axis=1)
y = df['viable']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = xgb.XGBClassifier(n_estimators=200, learning_rate=0.1, max_depth=5)
model.fit(X_train, y_train)

# Score new fullz
new_fullz = pd.DataFrame({'consistency_prob': [0.95], 'credit_score': [720], 'geo_match': [0.9], 'freshness_days': [15]})
score = model.predict_proba(new_fullz)[:, 1][0] * 100
print(f'Match Score: {score:.2f}/100')

This ranks efficiently — e.g., high-credit US fullz scores 90/100 for BNPL. Layer with BIN matching; dispute mismatches from vendors.