Best Web3 Rug Pull Detection Tools in 2026 — Ranked & Compared

Rug pulls cost crypto investors approximately $3 billion every year. On PancakeSwap alone, 95% of new liquidity pools end in rug pulls in different versions. On Pump.fun, 99% of launched tokens extract money from buyers. ChainAware’s own analysis of PancakeSwap V2 across the first 20 weeks of 2026 confirmed 103,695 rug pull events extracting $569,388,384 from retail investors — approximately $28.5M per week, every week, with zero media coverage.

This 2026 guide compares the seven most important Web3 rug pull detection tools available today — including a full breakdown of the newly launched ChainAware Rug Pull Detector V3, which achieves 90.1% prediction accuracy by combining behavioral analysis with smart contract code inspection. Understanding what each tool covers — and where each leaves gaps — is the most important security decision any DeFi participant makes in 2026.

Why Most Rug Pull Detection Tools Fail Against Professional Operators

Before comparing individual tools, it is worth understanding why the majority of detection approaches share a fundamental blind spot. Six of the seven tools in this guide analyze smart contract code — scanning for hidden mint functions, unlocked liquidity, blacklist mechanisms, proxy upgrade patterns, and honeypot traps. This approach works well against amateur operators who copy-paste malicious code from known scam templates.

Professional rug pull operations, however, are far more sophisticated. They know exactly which code patterns trigger detection tools. Consequently, they deliberately write clean, well-structured Solidity code that passes every contract scanner check. Their malicious intent does not appear in the code at all. Instead, it lives in their behavioral history — the same wallet addresses have been behind previous rug pulls, have interacted with known fraud infrastructure, and have executed liquidity manipulation patterns across multiple earlier schemes. All of that history sits permanently on-chain, unchanged and verifiable. Yet code-based scanners never look at it.

ChainAware Rug Pull Detector V3 addresses both surfaces simultaneously — behavioral history of the people behind the contract AND the smart contract code itself. This dual-pipeline architecture is what drives V3’s 90.1% prediction accuracy, up from 68% in V2 which relied on behavioral analysis alone. For the complete dataset behind V3’s training and validation, see our $569M PancakeSwap V2 analysis. According to Immunefi’s annual security reports ↗, exit scams and rug pulls consistently account for the largest share of total DeFi losses — and the majority involve operators who knew exactly how to evade detection.

The Two-Axis Framework for Understanding Detection Quality

Every rug pull detection approach falls somewhere on two axes: what data it analyzes (contract code vs. human behavioral history) and when it produces its signal (reactive after deployment vs. predictive before liquidity is drained). Code analysis is reactive by nature — it reads what is already deployed. Behavioral analysis is predictive — it identifies operators whose history makes future fraud probable, regardless of how clean their current code is. V3 is the only tool that operates across both axes simultaneously. For the complete technical analysis of these methodologies, see our Forensic vs AI-Powered Blockchain Analysis guide.

1. ChainAware.ai — Rug Pull Detector V3: Behavioral + Smart Contract Analysis

Core methodology: Dual-pipeline ensemble model — behavioral Trust Score analysis of contract creators and liquidity providers, combined with full smart contract code inspection via AST parsing and bytecode analysis.

ChainAware Rug Pull Detector V3 represents the most significant architecture upgrade in the detector’s history. V2 achieved approximately 68% prediction accuracy using behavioral analysis alone — examining the on-chain histories of contract creators and liquidity providers. V3 adds a complete smart contract analysis pipeline running in parallel, driving accuracy to 90.1%. The jump from 68% to 90.1% — a 32.5% relative improvement — closes the gap that sophisticated fraud operators had exploited by maintaining clean deployer wallet histories.

The key insight behind V3: behavioral analysis alone has a ceiling because experienced fraud operators invest in maintaining clean deployer identities — fresh wallets with legitimate-looking histories, funding through non-suspicious channels, and spaced deployment timing. These operators consistently fell into the 32% gap V2 could not close. Adding smart contract code inspection creates an independent second check that catches these operators even when their wallet history looks clean, because their fraudulent contracts still contain detectable risk patterns regardless of how their deployer wallet looks. For the complete V3 dataset and methodology, see our dedicated Rug Pull Detector V3 launch article with full PancakeSwap V2 data.

How V3 Works: The Two-Pipeline Architecture

V3 runs two completely independent analysis pipelines simultaneously. Each produces its own risk score. An ensemble model — trained on 103,695 confirmed rug pull events from PancakeSwap V2 — combines both scores into a single composite risk output between 0 and 100. This ensemble approach is what makes V3 robust against the evasion tactics that defeat single-method tools.

Pipeline 1: Creator Behavioral Analysis

The behavioral pipeline examines the complete on-chain history of the wallet that deployed the contract, plus the wallets that funded that deployer (the “feeder wallets”). ChainAware’s 20M+ wallet persona database, trained across 8 blockchains, provides the foundation. Five behavioral dimensions are evaluated:

• Deployment history: How many contracts has this wallet deployed, and what happened to their pools — did liquidity hold or get drained?
• Funding provenance: Where did the liquidity seed capital originate? Wallets funded from mixer outputs, fresh exchange withdrawals, or clusters of associated addresses receive elevated risk scores.
• Creator feeder analysis: The wallets that funded the deployer are independently scored. A deployer with a clean history but funded by a prior rug pull operator triggers a feeder-chain risk signal — this catches the “clean wallet, dirty money” pattern.
• Temporal patterns: How quickly were pools from this wallet or associated wallets drained after deployment? Short hold periods are the strongest behavioral predictor of rug pull intent.
• Wallet age and diversity: Fresh wallets created days before token deployment, with no prior DeFi activity beyond the deployment itself, score significantly higher than wallets with years of diverse on-chain history.

The behavioral pipeline is unchanged from V2 in its core logic but benefits from a larger, richer training dataset — the 103,695 confirmed events from the PancakeSwap V2 analysis added substantial new signal for the liquidity event timing and feeder wallet dimensions specifically.

Pipeline 2: Smart Contract Analysis

The smart contract pipeline inspects the deployed contract code directly — independently of who deployed it. For verified contracts with published source code, the analysis uses AST (Abstract Syntax Tree) parsing, examining the structural logic to identify dangerous function patterns. For unverified contracts where source code is not published, bytecode inspection detects characteristic opcode sequences associated with honeypot restrictions and hidden mint functions.

Five specific risk patterns are examined:

• Hidden transfer restrictions: Functions that block selling by non-owner addresses, often buried within complex conditional logic that does not appear dangerous in casual code review.
• Owner-privileged mint functions: Unrestricted mint capabilities controlled by the deployer allow unlimited token supply expansion after retail investors have bought in — diluting value to zero.
• Ownership renouncement status: Contracts that have not renounced ownership retain the ability to modify transfer restrictions, fee structures, and other critical parameters post-launch. Renounced ownership is a necessary but not sufficient condition for legitimacy.
• Liquidity lock verification: Whether LP tokens are locked, in what contract, and with what unlock conditions. Unlocked LP tokens in the deployer’s wallet represent immediate rug pull execution capability — one transaction away.
• Fee manipulation functions: Owner-callable functions to increase buy/sell taxes post-launch can make selling economically unviable, trapping investors while the creator exits.

This is what V3 adds that V2 did not have. A sophisticated operator who maintains a spotless deployer wallet but deploys a contract with hidden transfer restrictions now gets flagged by Pipeline 2 even when Pipeline 1 returns a clean signal. The combination closes the evasion gap. For a deeper technical comparison between contract-level and behavioral approaches in the broader blockchain security context, see our AI-Powered Blockchain Analysis guide.

The Ensemble Model: Composite Risk Score

Outputs from both pipelines feed into the ensemble model, which produces a single score from 0 to 100. Scores above 75 trigger a high-risk warning. Scores between 50 and 75 generate a medium-risk flag with specific contributing factors highlighted. Scores below 50 return a lower-risk assessment — though not a guarantee, since novel fraud patterns not yet in the training dataset may not be detected.

The ensemble model is continuously retrained as new confirmed rug pull events are added. This means V3’s accuracy improves over time rather than degrading as fraud operators develop new tactics. Full verification methodology — test set composition, false positive and false negative rates by pool type, and comparison to V2 baseline — is published at chainaware.ai/resources/rugpull-verification ↗.

V3 Specs at a Glance

Accuracy: 90.1% (V2 was 68%)
Chains: ETH, BNB, BASE, POLYGON, SOL, TON, TRON, HAQQ (8 chains)
Handles: Liquidity pools (additional LP checks) and individual token contracts
Speed: Full dual-pipeline analysis under 2 seconds
Free tier: Yes — chainaware.ai/rugpull, no signup required
Business API: chainaware.ai/subscribe
AI agents: X402 micropayment protocol enabled
Training data: 103,695+ confirmed PancakeSwap V2 rug pull events, continuously updated
Limitation: ~9.9% of events will not be flagged — concentrated in operators who both maintain clean behavioral history AND deploy contracts that pass automated inspection. No tool is 100%.

The Data Behind V3: $569M on PancakeSwap V2

V3’s ensemble model was trained and validated on a dataset that ChainAware published in May 2026 — the first comprehensive rug pull measurement ever conducted on PancakeSwap V2. The numbers are stark:

This data represents the conservative floor — only the most basic rug pull pattern was measured (creator adds liquidity, then removes more than added). More sophisticated extraction methods (LP token transfers, unlocked token sell-offs, associated party extraction, honeypot contracts) were not included. The real total is higher. Every confirmed event in this dataset became a labeled training example for V3’s ensemble model, making it the most empirically grounded rug pull detection model in the industry. For the complete week-by-week breakdown and analysis, see our dedicated $569M PancakeSwap V2 rug pull report.

2. GoPlus Security — Rules-Based API Infrastructure (30+ Chains)

Core methodology: Rules-based smart contract analysis — honeypot simulation, ownership flags, mint functions, blacklist/whitelist, tax parameters.

GoPlus Security is the dominant B2B security API in Web3. It powers the risk warnings on DEXScreener, is integrated into Sushi’s trading interface, and underlies security checks in dozens of wallets, explorers, and trading platforms. In Q4 2024 alone, GoPlus detected 67,241 honeypot tokens across Ethereum, Base, and BNB Chain. The platform covers over 30 blockchain networks and provides both a consumer-facing interface and a permissionless API that any developer can integrate without fees or approval.

What GoPlus Analyzes

GoPlus runs a comprehensive suite of contract-level checks: whether the token is sellable, whether the creator can mint unlimited new supply, whether blacklist or whitelist functions exist, whether the contract is open source, whether a proxy upgrade pattern is present, buy and sell tax rates, trading cooldown mechanisms, and LP lock status. These checks are fast, reliable, and cover the vast majority of amateur-level scam patterns. The API returns clear structured data that wallets and DEX aggregators can display to users in real time.

GoPlus is the right first-line tool for any token check. It does not, however, analyze the behavioral history of the people behind the contract — it does not know whether the deployer has a history of previous rug pulls on other tokens, and it does not inspect smart contract code with the depth of AST parsing or bytecode analysis that V3’s Pipeline 2 provides. For any asset trading on a major DEX, GoPlus provides reliable first-line protection. For new pools from unknown deployers, it is necessary but not sufficient.

Chains: 30+ EVM and non-EVM chains
Best for: First-line contract scanning; wallet and DEX integration via API; quick gut checks on any token
Free tier: Yes — free API and consumer interface
Limitation: Rules-based and static — cannot detect sophisticated operators with clean code; no behavioral history of creators

3. Token Sniffer — Pattern Matching and Clone Detection (EVM)

Core methodology: Automated code analysis with pattern matching, contract similarity detection against known scam templates, and honeypot simulation.

Token Sniffer is the most widely used free individual-user tool for EVM token risk assessment. Its core differentiator is contract similarity analysis — it maintains a database of known malicious contract patterns and scam templates and flags any new token whose code shares significant similarity with known fraudulent contracts. This catches the enormous volume of copy-paste scam operations that recycle the same malicious code structure across hundreds of new token deployments. Solidus Labs documented over 188,000 suspected scam tokens on Ethereum and BNB Chain in 2022 alone — the majority used recycled code that Token Sniffer can identify.

Token Sniffer produces a 0-100 risk score combining contract code analysis with swap simulation — testing whether an actual buy and sell transaction can be executed, which catches honeypot-style traps. It is particularly effective as a second-opinion tool to complement GoPlus results. The weakness is the mirror of its strength: it excels at catching copied code but cannot assess original code from operators who write from scratch, and it does not analyze creator behavioral history. For how pattern-matching approaches fit into a broader security framework, see our How to Identify Fake Crypto Tokens guide.

Chains: EVM chains (ETH, BNB, and others)
Best for: Catching copy-paste scams; second-opinion alongside GoPlus; screening high-volume new token launches
Free tier: Yes
Limitation: Cannot assess behavioral history; false positives on legitimate new tokens; no Solana support

4. De.Fi Scanner — Multi-Asset Portfolio Security (10+ Chains)

Core methodology: Comprehensive contract analysis across tokens, NFTs, and liquidity pools with multi-chain portfolio risk aggregation and PDF reporting.

De.Fi Scanner — built by the team behind De.Fi (formerly DeFiYield) — positions itself as the “antivirus of blockchains” with the most ambitious scope of any tool in this comparison. Where GoPlus and Token Sniffer focus on individual token contracts, De.Fi Scanner extends its analysis to NFTs, liquidity positions, and entire portfolio exposures across 10+ networks simultaneously. This makes it particularly valuable for users managing complex multi-chain DeFi portfolios who need a unified risk picture rather than token-by-token checks.

De.Fi’s interface is notably more visual and information-dense than GoPlus’s API-first presentation — it displays social links, market cap, exchange rankings, and permission flags alongside risk scores. The platform’s ability to generate downloadable PDF audit reports is useful for institutional users and launchpad teams. Like GoPlus and Token Sniffer, De.Fi Scanner analyzes contract code rather than behavioral history, sharing the same fundamental limitation against professional operators with clean code.

Chains: 10+ (ETH, BNB, SOL, Polygon, Arbitrum, others)
Best for: Multi-chain portfolio risk management; institutional due diligence with PDF reports; combined token + NFT + LP risk assessment
Free tier: Yes
Limitation: Complex UI for quick checks; code analysis only; no behavioral creator history

5. RugCheck.xyz — Solana-Native Detection (Solana)

Core methodology: Solana-specific token analysis — liquidity locks, holder distribution, ownership concentration, insider network detection.

RugCheck.xyz holds a unique position as the dominant Solana-specific tool — widely referred to as “the Solana traffic light” by the memecoin community. For anyone active in Solana’s memecoin ecosystem or participating in early Pump.fun launches, RugCheck.xyz has become a standard part of the due diligence workflow. Its most distinctive feature is Insider Networks analysis — identifying suspicious relationships between major token holders, flagging cases where multiple large holders share characteristics suggesting coordinated insider buying. This targets a specific rug pull pattern common on Solana where a team seeds the holder distribution to appear decentralized while actually controlling the majority of supply. For broader context on Solana security challenges and the 99% Pump.fun scam rate, see our Rug Pull vs Pump and Dump guide.

Chains: Solana only
Best for: Solana memecoin research; Pump.fun launch screening; quick mobile-friendly Solana checks
Free tier: Yes
Limitation: Solana-only; no behavioral history; does not evaluate team background or off-chain conduct

6. Webacy — Predictive ML on Base (Base)

Core methodology: Supervised machine learning (GBDT, XGBoost, LightGBM) combining Solidity code forensics with on-chain holder analytics for predictive rug probability scoring.

Webacy stands out as the most technically ambitious approach among the code-analysis tools — and the closest in philosophy to ChainAware’s predictive methodology, though applied primarily to Base chain and incorporating contract code as a primary input. Webacy’s system combines two data streams: Solidity code-level features (hidden mint, risky primitives, upgradeability patterns) available immediately at deployment, and on-chain holder analytics (early sniper clustering, concentrated early ownership, bundled trading) that become available as the token begins trading. The model weights these through ML rather than fixed rules, giving it more flexibility to adapt to novel patterns than purely rules-based systems like GoPlus.

Webacy’s current limitation is scope: it focuses on Base chain. Users on ETH, BNB, or Solana do not benefit from this predictive layer. Additionally, it relies partially on contract code features — meaning sophisticated operators who write clean code and avoid sniper-detectable trading patterns can still partially evade detection. For how ML-based approaches differ from rules-based systems, see our AI-Powered Blockchain Analysis guide.

Chains: Base (primary, expanding)
Best for: Base chain token launches; early deployment risk scoring; ML-based analysis beyond fixed rules
Free tier: Yes
Limitation: Primarily Base-focused; still incorporates contract code features; less behavioral depth than creator-history analysis

7. QuillCheck by QuillAI — Real-Time Monitoring and Alerts (Multi-Chain)

Core methodology: 25+ smart contract and market condition parameters with 24/7 continuous monitoring, real-time Telegram and Twitter alerts when tokens turn into scams.

QuillCheck differentiates itself through continuous monitoring rather than point-in-time checks. Where most scanners return a risk assessment at the moment of query, QuillCheck monitors token contracts 24/7 and delivers automated alerts via Telegram and Twitter when a previously clean-scoring token subsequently changes behavior. This monitoring capability addresses one of the most insidious rug pull patterns: tokens that appear completely clean at launch but activate malicious functions after a waiting period once sufficient investor funds have accumulated — the “time-bomb” rug pull. QuillCheck’s API is specifically designed for launchpad and DEX integration, enabling platforms to screen every project submission automatically and continue monitoring listed tokens post-launch. For how transaction monitoring approaches apply to DApps beyond token screening, see our Transaction Monitoring Agent guide.

Chains: Multi-chain EVM
Best for: Real-time monitoring of holdings; launchpad automated screening; platforms needing post-launch surveillance
Free tier: Yes
Limitation: Contract code analysis only; alert timing vs. fast rug pulls; no behavioral creator history

Head-to-Head Comparison Table

Tool	Detection Method	V3 Accuracy	Catches Clean-Code Pros?	Chains	Monitoring?	Free	API
ChainAware V3	Behavioral history + Smart contract analysis (AST + bytecode)	90.1%	✅ Yes — dual pipeline	8 chains	✅ Transaction monitoring agent	✅	✅ MCP + REST + X402
GoPlus Security	Rules-based contract code	~70–75% (estimated)	❌ No	30+ chains	❌	✅	✅ Open API
Token Sniffer	Pattern matching + clone detection + honeypot sim	Good on clones	❌ No	EVM	❌	✅	Limited
De.Fi Scanner	Multi-asset contract analysis + permission flags	Moderate	❌ No	10+ chains	❌	✅	✅
RugCheck.xyz	Liquidity locks + holder distribution + insider networks	Good on Solana	❌ No	Solana only	❌	✅	Limited
Webacy	Predictive ML: code forensics + holder analytics	Improving	Partial	Base (primary)	Partial	✅	✅
QuillCheck	25+ contract parameters + continuous monitoring	Moderate	❌ No	Multi-chain EVM	✅ 24/7 alerts	✅	✅ Launchpad-focused

Detection Method Comparison: What Each Approach Catches and Misses

Rug Pull Type	ChainAware V3	GoPlus	Token Sniffer	De.Fi	RugCheck	Webacy	QuillCheck
Honeypot (can’t sell)	✅ Pipeline 2 (AST/bytecode) + Pipeline 1	✅ Strong	✅ Swap simulation	✅	✅	✅	✅
Unlocked liquidity drain	✅ Pipeline 2 LP lock check + Pipeline 1 behavioral	✅ LP lock check	✅	✅	✅ Solana	✅	✅
Hidden mint / unlimited supply	✅ Pipeline 2 mint function detection	✅ Strong	✅	✅	✅	✅	✅
Fee manipulation post-launch	✅ Pipeline 2 detects fee manipulation functions	Partial	Partial	Partial	Partial	Partial	✅ via monitoring
Copy-paste scam code	✅ Pipeline 2	✅	✅ Strongest	✅	Partial	✅	✅
Delayed activation (time-bomb)	✅ Pipeline 1 operator history	❌	❌	❌	❌	Partial	✅ 24/7 monitoring
Professional clean-code operator	✅ Pipeline 1 behavioral history — primary differentiator	❌	❌	❌	❌	Partial	❌
Insider / coordinated supply	✅ Pipeline 1 LP cluster analysis	Partial	Partial	Partial	✅ Insider Networks	✅ Sniper detection	Partial
New wallet, no history	⚠️ Limited behavioral signal — Pipeline 2 still runs	✅	✅	✅	✅	✅	✅

Which Tool Should You Use — and When?

No single tool covers every rug pull type. Professional security practice in 2026 combines multiple tools to close the gaps each one leaves. Here is the practical framework:

For Individual Investors: The Three-Check Stack

Step 1 — Contract check (GoPlus or Token Sniffer): Run any new token through GoPlus for immediate contract-level flags. Token Sniffer adds clone detection as a second opinion. Together they catch the majority of amateur-level scams in 30 seconds.

Step 2 — V3 pool check (ChainAware Rug Pull Detector V3): Submit the pool address or token contract to V3. The dual-pipeline analysis returns a 0–100 composite risk score covering both the behavioral history of the deployer and a full smart contract code inspection. This is the only step that catches professional operators with clean code. It also catches the contract-level risks that GoPlus covers, providing a comprehensive second-opinion from both angles simultaneously.

Step 3 — Ongoing monitoring (QuillCheck alerts): For positions you hold for more than a few days, set up QuillCheck alerts on the contract. Post-launch behavioral changes — fee increases, LP removal preparation — appear before the actual rug pull. Early warning gives you an exit window. For Solana specifically, substitute RugCheck.xyz in Step 1. For multi-chain portfolio exposure, add De.Fi Scanner to your Step 1 workflow.

For DApps and Launchpads: API-Level Integration

DApps and launchpads need API-level automation. The recommended stack is GoPlus API for real-time contract-level screening, ChainAware V3 API for behavioral + smart contract risk scoring of addresses and pools interacting with your platform, and QuillCheck API for continuous post-listing monitoring with automated alerts. This combination covers all three temporal phases: before launch (V3 + GoPlus), at launch (V3 + GoPlus), and post-launch (QuillCheck).

For DApps that also need to screen the wallets connecting to their platform — not just tokens — ChainAware’s Transaction Monitoring Agent screens every connecting wallet at the moment of connection via Google Tag Manager pixel, with Telegram alerts and webhook automation for automatic blocking. No code changes required, active in 12 minutes. See our Transaction Monitoring Agent guide for the full integration walkthrough. For the regulatory compliance requirements that make transaction monitoring mandatory under MiCA, see our DeFi Compliance Tools comparison and our MiCA Compliance guide.

Frequently Asked Questions

What is the difference between ChainAware V2 and V3?

V2 relied exclusively on behavioral analysis of contract creator wallets, achieving approximately 68% prediction accuracy. V3 adds a full smart contract analysis layer — Pipeline 2 — running in parallel with behavioral analysis. This closes the gap that sophisticated fraud operators exploited in V2 by maintaining clean deployer histories while deploying fraudulent contracts. The combined V3 ensemble model achieves 90.1% prediction accuracy, a 32.5% relative improvement. The training dataset for V3’s ensemble model includes 103,695 confirmed rug pull events from PancakeSwap V2, measured across Weeks 1–20 of 2026.

Can any tool guarantee 100% rug pull detection?

No. V3 achieves 90.1% accuracy — approximately 9.9% of events will not be flagged. These false negatives are concentrated in operators who both maintain clean behavioral histories AND deploy contracts that pass automated inspection. No tool is 100%, and any tool claiming to be should be treated with skepticism. The practical goal is eliminating the categories of rug pull that are systematically preventable while continuously improving through retraining on new confirmed events. Full methodology and accuracy breakdown is published at chainaware.ai/resources/rugpull-verification.

Why do professional rug pulls pass contract scanners?

Professional operators know exactly which code patterns trigger GoPlus, Token Sniffer, and similar tools. They deliberately write clean Solidity code containing none of the flagged patterns. Their malicious intent exists only in their behavioral history — prior rug pulls, interactions with known fraud wallets, patterns of deploying and draining pools across multiple schemes. That history is permanently on-chain but contract scanners never look at it. V3’s Pipeline 1 reads exactly that history. V3’s Pipeline 2 then independently inspects the contract code, catching operators who write clean-looking code that still contains detectable dangerous function patterns when analyzed at the AST or bytecode level.

Which tool is best for Solana memecoins?

RugCheck.xyz is the community standard for Solana token screening — accessible, widely adopted, and with Insider Networks detection specifically relevant to coordinated supply manipulation common in Solana memecoins. ChainAware currently covers ETH, BNB, BASE, POLYGON, SOL, TON, TRON, and HAQQ across its full product suite, with Rug Pull Detector V3 optimized for BNB Chain and Ethereum in its current version. For now, the best Solana approach combines RugCheck.xyz with ChainAware’s Fraud Detector for manual creator wallet checks.

Should I use multiple tools simultaneously?

Yes — strongly recommended. Each tool catches a different category. GoPlus catches amateur code-based scams. Token Sniffer catches copy-paste operations. RugCheck catches Solana-specific patterns. ChainAware V3 catches sophisticated operators with its dual behavioral + smart contract pipeline. QuillCheck catches post-launch behavioral changes. Running V3 plus one code scanner plus QuillCheck for monitoring takes under five minutes and dramatically expands your protection coverage. If two independent tools flag different risks on the same contract, that disagreement alone is a signal worth investigating before committing funds.

How does ChainAware’s rug pull detection relate to its fraud detection?

The Fraud Detector evaluates individual wallet addresses — producing a fraud probability score for any address based on its transaction history. The Rug Pull Detector V3 applies that fraud probability analysis to the specific set of addresses involved in a liquidity pool — the contract creator, any upstream creators, and all liquidity providers — then combines that behavioral assessment with a full smart contract code inspection to produce a composite risk score for the pool as a whole. The rug pull detector uses fraud detection as a component within a broader dual-pipeline ensemble model. Both tools are free at chainaware.ai. For the complete product overview including how both tools fit the broader ChainAware stack, see our complete product guide.

Sources: Immunefi Web3 Security Research ↗ · Chainalysis Crypto Crime Report ↗ · FATF Virtual Assets Recommendations ↗ · GoPlus Security ↗ · ChainAware V3 Verification Methodology ↗