AI-Powered Token Scoring for Mobile Apps – Detect Scams & Rug Pulls

Adding analysis of cryptocurrency projects to a mobile app is a task we solve with AI scoring. The system objectively evaluates tokens and helps users avoid scams. Dozens of new tokens launch weekly: according to CoinMarketCap, the number grew by 30% in the last year alone. Most are junk, some are scams, and only a few are real projects. Our system filters out obviously bad projects and prioritizes analysis of promising ones. Over 5 years, we have completed 30+ projects in DeFi and blockchain, building a database of scam patterns. The scoring model uses rule-based logic and ML to detect anomalies. The result is a score from 0 to 100 with a detailed breakdown and warnings. We developed a data pipeline in Python that aggregates data on a schedule and updates scores. For on-chain data we use Moralis API, for GitHub — REST API. Every morning the model recalculates scores for thousands of tokens. In one project, implementing the system allowed users to identify scam tokens 40% faster and reduce fraud losses by 60%. The financial savings from analysis automation reached 70% of manual monitoring costs.

What Parameters Affect the Score?

A good scoring system covers multiple dimensions:

Technology & Development

• GitHub activity: commits in the last 30/90 days, contributors, open issues
• Code quality: presence of tests, audit reports
• Tech stack: blockchains used, token standards

Team

• Verified identities vs anonymous (risk factor)
• LinkedIn profiles, public history
• Previous projects and their fate

Tokenomics

• Token distribution: % to team, investors, public
• Vesting schedule: presence of lock-up periods
• Inflationary/deflationary model
• Circulating vs total supply ratio

Market Metrics

• Market cap / FDV ratio (Fully Diluted Valuation)
• Liquidity depth: volume in DEX pools
• Holder distribution: top 10 holders and their % of supply

Community

• Twitter followers and engagement rate (not bought)
• Telegram/Discord activity vs size

Data Sources

class TokenDataAggregator: def get_github_metrics(self, repo_url: str) -> dict: # GitHub API v3 import requests owner, repo = self._parse_repo_url(repo_url) headers = {"Authorization": f"token {GITHUB_TOKEN}"} commits_30d = requests.get( f"https://api.github.com/repos/{owner}/{repo}/commits", params={"since": (datetime.now() - timedelta(days=30)).isoformat()}, headers=headers ).json() contributors = requests.get( f"https://api.github.com/repos/{owner}/{repo}/contributors", headers=headers ).json() return { "commits_30d": len(commits_30d) if isinstance(commits_30d, list) else 0, "contributors_count": len(contributors) if isinstance(contributors, list) else 0, "stars": self._get_repo_stars(owner, repo, headers) } def get_onchain_metrics(self, contract_address: str, chain: str) -> dict: # Moralis API — supports ETH, BSC, Polygon, and others response = requests.get( f"https://deep-index.moralis.io/api/v2.2/erc20/{contract_address}/owners", params={"chain": chain, "limit": 10}, headers={"X-API-Key": MORALIS_API_KEY} ) holders = response.json() top10_concentration = sum(h["percentage_relative_to_total_supply"] for h in holders.get("result", [])[:10]) return {"top10_holder_concentration": top10_concentration} 

Moralis API aggregates on-chain data from many EVM-compatible networks. Covalent API is an alternative with historical data. For Solana, we use Helius or direct Solana RPC.

Scoring System Architecture

Rule-Based Scoring Engine

We start with a set of weighted rules. This is transparent and explainable — important for users who want to understand the score:

class TokenScorer: WEIGHTS = { "github_activity": 0.15, "team_transparency": 0.20, "tokenomics_health": 0.25, "liquidity_score": 0.20, "community_quality": 0.10, "audit_status": 0.10, } def score_github(self, metrics: dict) -> float: score = 0.0 if metrics["commits_30d"] > 50: score += 0.4 elif metrics["commits_30d"] > 10: score += 0.2 if metrics["contributors_count"] > 5: score += 0.3 elif metrics["contributors_count"] > 2: score += 0.15 return min(score, 1.0) def score_tokenomics(self, data: dict) -> float: score = 1.0 # Penalty for high team concentration if data["team_allocation_pct"] > 30: score -= 0.3 # Penalty for lack of vesting if not data["has_vesting"]: score -= 0.25 # Penalty for low circulating ratio (many tokens still to be released) if data["circulating_ratio"] < 0.2: score -= 0.2 return max(score, 0.0) 

How ML Rug Pull Detection Works

The ML component identifies patterns typical of rug pulls. We train on historical data: tokens that performed rug pulls and legitimate projects. The rule-based approach is 2x faster to implement, but ML gives 30% fewer false positives. The model is trained on a dataset of 2000+ confirmed scam tokens from DeFiLlama Hacks dashboard and Token Sniffer.

Rug pull indicators in data:

• Contract creator removed liquidity pool within 30 days
• Honeypot: cannot sell token (sell function is blocked in contract)
• Proxy contract with upgradable logic without timelock
• 90%+ supply held by one address

from sklearn.ensemble import GradientBoostingClassifier # Rug pull detector features = [ "top1_holder_pct", "lp_lock_days", "is_proxy_contract", "sell_function_exists", "owner_renounced", "audit_score", "github_commits_30d", "holder_count" ] model = GradientBoostingClassifier(n_estimators=100, max_depth=4) model.fit(X_train, y_train) # y: 1 = rug pull, 0 = legitimate 

Honeypot Check

A separate critical check — whether the token can be sold. We simulate a sell transaction before interacting with the contract:

from web3 import Web3 def check_honeypot(contract_address: str, router_address: str) -> bool: w3 = Web3(Web3.HTTPProvider(RPC_URL)) # Simulate selling a minimal amount of the token try: router = w3.eth.contract(address=router_address, abi=ROUTER_ABI) router.functions.swapExactTokensForETHSupportingFeeOnTransferTokens( 1, # 1 wei equivalent of token 0, [contract_address, WETH_ADDRESS], ZERO_ADDRESS, int(time.time()) + 60 ).call({"from": TEST_WALLET}) return False # sale succeeded = not honeypot except Exception: return True # revert = honeypot 

This is a call, not a send — no gas spent, no transaction written to the blockchain.

Mobile UI

The final score is a number from 0 to 100 with color coding (red < 40, yellow 40–70, green > 70). But a score without explanation is a black box. Next to the score, we show a breakdown by category: what lowered the rating.

struct TokenScore: Codable { let overallScore: Double // 0-100 let riskLevel: RiskLevel // .low, .medium, .high, .critical let breakdown: ScoreBreakdown let warnings: [String] // ["Honeypot detected", "No audit report"] let lastUpdated: Date } struct ScoreBreakdown: Codable { let technology: Double let team: Double let tokenomics: Double let liquidity: Double let community: Double } 

Warnings are prioritized: honeypot gets a red banner immediately, low liquidity gets a yellow warning at the bottom.

How We Implement the System

Work Process

1. Determine scoring parameters together with the client.
2. Develop data pipeline: GitHub API, on-chain data, social metrics.
3. Build rule-based scoring engine.
4. Train ML model for rug pull detection and honeypot.
5. Build REST API with caching (token data refreshed once per hour).
6. Build mobile UI: token card with score and breakdown.

What's Included

• Source code (backend + mobile) under MIT license.
• API documentation (Swagger).
• Admin panel for updating scoring weights.
• Training for the client's team.
• 30 days of post-release support.

Estimated Timelines

Our Experience & Guarantees

We have 5+ years of mobile development experience, completed 30+ projects in DeFi and blockchain. We offer a one-month bug-free guarantee post-delivery. We transfer complete documentation and update the system as data source APIs change.

Get a consultation — our engineers will help determine the optimal scoring architecture for your project. Contact us to discuss details and timelines. Request an assessment of your project now.