Fraud detection explainability

Since Sep 24Updated Nov 20, 2026Based on 21 AI answersReviewed by

How we measure

Brands AI recommends

Mentioned in, on ChatGPT and Google AI Mode
  • SHAPChatGPTChatGPT 100%Google AI ModeGoogle AI Mode 80%
  • Fiddler AIChatGPTChatGPT 18%Google AI ModeGoogle AI Mode 40%
  • Arize AIChatGPTChatGPT 9%Google AI ModeGoogle AI Mode 40%
  • XGBoostChatGPTChatGPT 18%Google AI ModeGoogle AI Mode 40%
  • CaptumChatGPTChatGPT 0%Google AI ModeGoogle AI Mode 30%

Questions and answers

  • Google AI ModeNov 9, 2026

    1. 1XGBoost
    2. 2LightGBM
    3. 3LIME
    4. 4Elasticsearch
    5. 5Captum
    6. 6PyTorch
    7. 7Amazon S3

    Achieving transparency and building an auditable trail for a fraud detection model requires combining local post-hoc explainability methods with a durable logging and governance architecture.

    1. Choose the Right Explainability Framework

    For transaction-level auditing, you need local explanations (explaining a single flagged transaction) rather than global ones (explaining what the model likes overall).

    • TreeSHAP / SHapley Additive exPlanations:
      • Best for: Tree-based models (XGBoost, LightGBM, Random Forests) commonly used in fraud detection.
      • Why: It breaks down a transaction's fraud score into the exact additive contribution of each feature (e.g., transaction amount +$0.45, IP mismatch +$0.30, unusual velocity -$0.10 ). It has a strong mathematical foundation (game theory) and is widely accepted by compliance and risk auditors. Explore technical implementation via ResearchSquare's Financial ML Explainability Study.
    • LIME (Local Interpretable Model-agnostic Explanations):
      • Best for: Black-box models (deep neural networks or complex ensembles) where you cannot peek into the tree structures.
      • Why: It fits a local surrogate linear model around the specific transaction to approximate why the model tipped over the fraud threshold. (Note: Can sometimes be less stable across runtimes than SHAP).
    • Meta-Learning / Error-Analysis Layer:
      • Best for: Reducing alert fatigue and distinguishing true positives from false positives.
      • Why: According to risk insights like Milliman's Explainable AI in Fraud Detection , stacking a secondary model to explain why an alert is a true versus false positive gives investigators a much more actionable narrative than raw feature weights alone.

    2. Design an Auditable Transaction Pipeline

    An explanation is useless for auditing if it isn't permanently tied to the exact state of the model and data at the millisecond the decision was made.

    1. Capture Snapshot Metadata (The "Inference Payload"):
      • Do not just log the feature values at audit-time. Log the exact pre-processed feature vector that entered the model.
      • Record the Model Version/Hash and Feature Store Timestamp alongside the prediction score.
    2. Store Feature Contribution Vectors:
      • For every flagged transaction, compute and store the top k positive and negative feature contributions (e.g., top 5 SHAP values) directly in your transaction or audit database.
    3. Immutability & Access Control:
      • Write the explanation payload to a write-once-read-many (WORM) or append-only audit log (e.g., structured JSON logs shipped to an immutable S3 bucket, Elasticsearch, or a dedicated governance database) so investigators or regulators can replay the decision path.
      • Provide a lightweight Analyst UI / Drill-Down Tool that renders these feature contributions in plain English (e.g., "Flagged because: 1) Velocity exceeded 5× baseline, 2) New device fingerprint, 3) High-risk BIN country").

    3. Implement a Step-by-Step Action Plan

    1. Audit your current model type: Determine if it's white-box (trees) or black-box (neural net/ensemble) to pick SHAP or LIME.
    2. Integrate real-time calculation: Run your explainability library (like shap or captum for PyTorch) asynchronously or via a lightweight sidecar service so it doesn't add unacceptable latency to your sub-100ms checkout/payment flow.
    3. Build the audit schema: Ensure your database tracks:
      • transaction_id
      • model_version
      • fraud_probability_score
      • decision_threshold
      • top_contributing_features_json
      • timestamp
    4. Validate fidelity: Periodically test that your local explanations faithfully represent the model's actual behavior (local fidelity checks).

    To help tailor this to your setup, could you share:

    • What kind of model are you running (e.g., XGBoost, Logistic Regression, Deep Learning)?
    • Where does the output go (e.g., real-time payment gateway block, or a queue for human analyst review)?

    ChatGPTNov 9, 2026

    1. 1SHAP
    2. 2XGBoost
    3. 3LightGBM
    4. 4Random Forest
    5. 5FastAPI
    6. 6PostgreSQL
    7. 7Grafana
    8. 8React
    9. 9MLflow
    10. 10Apache Kafka
    11. 11Microsoft Power BI

    To get meaningful transparency into your fraud detection model, I recommend building an automated, transaction-level explainability and audit trail system.

    The goal is to ensure that every flagged transaction has a defensible explanation of:

    1. Why it was flagged.
    2. Which factors contributed to the fraud score.
    3. How much each factor influenced the decision.
    4. What evidence was available when the decision was made.
    5. Whether a human reviewer agreed with the model's assessment.

    Importantly, you want explanations that are reproducible and auditable—not just AI-generated descriptions of model behavior.

    1. Implement explainable AI (XAI)

    For each flagged transaction, use an explainability method appropriate to your model.

    TechniqueWhat it provides
    SHAPQuantifies how individual features contribute to a prediction
    LIMEExplains an individual prediction using a locally interpretable approximation
    Feature importanceIdentifies influential features across the model
    Counterfactual explanationsShows what would need to change for a transaction to receive a different classification

    My recommendation: Start with SHAP if you're using tree-based fraud models such as XGBoost, LightGBM, or Random Forest. It provides a useful foundation for transaction-level explanations.

    2. Generate a standardized explanation for every flagged transaction

    Create a structured explanation record whenever the model flags a transaction.

    For example:

    Transaction explanation (Flagged)

    Transaction ID

    TXN-847291

    Fraud probability

    94.2%

    Model version

    fraud-model-v3.8

    Decision timestamp

    2026-11-09 01:41 UTC


    Top contributing factors


    Human-readable explanation

    The transaction was flagged because its amount was substantially higher than the customer's historical spending pattern. The device was previously unseen, and the transaction originated from a location inconsistent with recent account activity.

    Explanation generated and stored

    Illustrative example only. The percentages are illustrative contribution shares, not actual SHAP values.

    Your actual system should retain the raw SHAP values, baseline, feature values, and model output alongside this readable explanation.

    I would make these fields mandatory:

    • Transaction ID and decision timestamp.
    • Model name, version, and deployment identifier.
    • Input feature values used for scoring.
    • Fraud score and decision threshold.
    • SHAP values and top contributing features.
    • Data source and feature freshness information.
    • Explanation-generation method and version.
    • Final action: flagged, blocked, reviewed, or released.
    • Human reviewer, override reason, and final outcome, where applicable.

    The ICO's guidance on explaining AI decisions specifically highlights explaining the input data, its sources, and the rationale behind individual outcomes.

    3. Build an immutable audit trail

    This is what turns explainability into genuine auditability.

    For every flagged transaction, preserve a point-in-time record containing:

    Audit componentWhat to retain
    Model lineageModel version and artifact hash
    Data lineageInput features and source references
    DecisionScore, threshold, and resulting action
    ExplanationSHAP values and generated reason codes
    ProcessingTimestamp and explanation version
    Human reviewReviewer decision and override rationale
    OutcomeConfirmed fraud, false positive, or unresolved

    I recommend:

    • Append-only or tamper-evident audit storage.
    • Cryptographic hashes for important decision artifacts.
    • Role-based access controls.
    • Defined retention policies.
    • Ability to reproduce historical decisions using the original model and feature snapshot.

    A particularly important distinction: Never regenerate an old explanation using today's model and present it as the explanation for yesterday's decision.

    Preserve the original decision context.

    This approach is consistent with banking auditability principles and model governance recommendations.

    4. Create a fraud investigation dashboard

    Give fraud analysts, compliance teams, and model risk managers a common interface.

    Fraud intelligence overview (Illustrative dashboard)

    1,284

    Flagged transactions

    96.8%

    Explanation coverage

    142

    Awaiting review

    8.4%

    False-positive rate

    Transaction review queue

    TransactionScorePrimary reason

    Synthetic dashboard data, not live transaction information.

    Useful dashboard capabilities include:

    • Search by transaction ID, customer, or date.
    • Drill down into individual explanations.
    • Compare model decisions with human decisions.
    • Export evidence packages for auditors.
    • Monitor explanation coverage and generation failures.
    • Identify features responsible for increasing false positives.

    5. Recommended technical architecture

    I would implement this as a separate explainability service alongside your existing fraud scoring pipeline.

    mermaid
    
    flowchart TD
        A[Incoming Transaction] --> B[Feature Engineering]
        B --> C[Fraud Detection Model]
        C --> D[Fraud Score and Decision]
        D --> E[Explainability Service]
        E --> F[SHAP Attribution]
        E --> G[Reason Code Generator]
        F --> H[Explanation Record]
        G --> H
        H --> I[Immutable Audit Store]
        H --> J[Fraud Investigation Dashboard]
        J --> K[Human Review]
        K --> L[Investigation Outcome]
        L --> I

    Suggested technology stack:

    ComponentSuggested technology
    Fraud modelXGBoost, LightGBM, existing ML model
    ExplainabilityPython SHAP
    Event processingKafka
    Explanation APIFastAPI
    Audit databasePostgreSQL
    Tamper-evident storageImmutable object storage
    DashboardPower BI, Grafana, or custom React
    Model monitoringMLflow or equivalent

    You don't necessarily need to replace your existing fraud model. You can add this layer around it.

    6. Important safeguards

    There are a few pitfalls worth addressing before deployment.

    1. Don't confuse correlation with causation.

    SHAP identifies contributions to a model prediction, not proof that a transaction is fraudulent.

    2. Validate explanations.

    Test whether explanations are stable, meaningful, and consistent with actual model behavior.

    3. Protect sensitive information.

    Limit access to customer information and avoid exposing sensitive fraud detection rules to unauthorized users.

    4. Monitor explanation quality.

    Track:

    • Percentage of flagged transactions with explanations.
    • Explanation generation failures.
    • Stability of top contributing features.
    • False-positive and false-negative rates.
    • Human override frequency.

    5. Don't rely exclusively on post-hoc explanations.

    Where practical, combine explainability with interpretable rules, documented model design, and independent model validation.

    These principles are particularly relevant to financial services model governance.

    7. A practical implementation roadmap

    PhaseDeliverableIndicative timeline
    1Assess model and feature pipelineWeek 1
    2Integrate SHAP explanationsWeeks 2–3
    3Build standardized reason codesWeek 4
    4Implement audit loggingWeeks 5–6
    5Build analyst dashboardWeeks 7–8
    6Validate and deployWeeks 9–10

    Useful technical references:


    My recommendation: Start with an explanation API

    Rather than building an entire dashboard first, start with an API that accepts a transaction ID and returns a structured, reproducible explanation.

    This gives you the foundation for analyst dashboards, audit reports, compliance evidence, and automated investigations.

    One important question before choosing the implementation:

    What type of fraud detection model are you currently running?

    1. Current model

    XGBoost / LightGBM

    Random Forest

    Neural network / Deep learning

    Rules-based system

    Ensemble / Hybrid model

    Other / Not sure


    2. How is it deployed?

    Real-time transaction scoring

    Batch processing

    Both


    3. Who needs the explanations?

    Internal audit and compliance

    Fraud investigation analysts

    Both

    External regulators and customers

    [Design my implementation]

    With those details, I can help design a concrete implementation, including the Python explanation engine, API, audit record schema, and transaction-level explanation reports.

  • ChatGPTOct 21, 2026

    1. 1SHAP
    2. 2Fiddler AI
    3. 3DataRobot

    Yes. If your goal is to make a fraud detection system transparent, look for an explainable AI (XAI) tool with transaction-level explanations and an audit trail. These tools can help your team understand not just which transactions were flagged, but why, which factors influenced the decision, and whether the decision can be reproduced later for compliance or investigation.

    For a production fraud system, I'd prioritize four capabilities:

    • Per-transaction explanations: Identify the specific features that contributed to a fraud score, such as unusual transaction size, device changes, or velocity patterns.
    • Auditable decision records: Store the model version, input features, score, explanation, timestamp, and decision outcome.
    • Reproducibility: Enable investigators to reconstruct the decision using the model and data available at the time.
    • Human review: Give analysts a way to challenge a flag, record their rationale, and track the final disposition.

    Tools worth evaluating

    • Applying explainable artificial intelligence to interpret supervised ensemble learning models for robust credit card fraud detection | Scientific Reports

    1. SHAP — best flexible starting point

    (Open source)

    Generates explanations for individual predictions, showing which features pushed a fraud score up or down. It works with many model types and is useful when you want to retain control of your existing system. You'll need to build the audit log and analyst interface around it.

    Documentation: SHAP docs ·


    • How to Design to Make AI Explainable | Fiddler AI Blog

    2. Fiddler AI — best to evaluate for governance

    A commercial AI observability platform to consider if you need model explanations alongside monitoring, performance tracking, and governance workflows. Validate whether its current product and integration support your specific transaction-level audit requirements.

    Website:


    • Individual Prediction Explanations (XEMP): DataRobot docs

    3. DataRobot — best to evaluate for enterprise workflows

    Provides individual prediction explanations using SHAP or other supported explanation methods, with ways to inspect and download explanations. Consider it if your team also needs enterprise model management and analyst workflows.

    Documentation:

    What I would implement

    For a fraud detection system, I'd start with SHAP plus an immutable decision log, unless you specifically need a managed commercial platform.

    Each flagged transaction should produce a record like this:

    Illustrative transaction explanation

    (Flagged)

    Risk score

    0.94

    Model version

    fraud-v12

    Illustrative contributing factors

    Unusual transaction amount

    High

    Rapid transaction frequency

    High

    Previously trusted device

    Offsets risk


    Audit metadata: transaction ID · event timestamp · model and rules versions · input-data snapshot or hash · explanation method/version · threshold applied · reviewer and final disposition

    The values above are illustrative, not real model output.

    One important distinction: a SHAP explanation tells you how model features contributed to a prediction; it doesn't, by itself, prove the prediction was correct or guarantee an audit-ready record. Preserve the underlying decision context, validate explanation stability, and control access to sensitive transaction data.

    Which approach fits your system?

    1. How is your fraud system deployed?

    Existing custom-built system

    Primarily on AWS or another cloud

    Looking for a managed enterprise platform


    2. What matters most?

    Audit trails and regulatory reviews

    Fraud analyst investigations and fewer false positives

    Low-latency explanations at transaction time


    3. What type of model do you use?

    XGBoost, LightGBM, or other tree-based model

    Neural network or deep learning

    Rules-based system or hybrid model

    Not sure / other

    [Find the best-fit solution]

    Google AI ModeOct 21, 2026

    1. 1SHAP
    2. 2Feedzai
    3. 3Sift

    Yes, you can use Explainable AI (XAI) frameworks and decision-intelligence platforms like SHAP (SHapley Additive exPlanations) or commercial enterprise fraud tools (such as Feedzai or Sift) that natively generate feature-contribution scores and audit logs for every flagged transaction.

    Popular XAI Tools and Methods

    • SHAP (SHapley Additive exPlanations): An open-source library based on game theory that calculates the exact impact of each data field (e.g., location, transaction size) on a specific fraud score.
    • LIME (Local Interpretable Model-agnostic Explanations): An open-source tool that approximates your complex machine learning model locally around a single transaction to show why it triggered an alert.
    • Enterprise Fraud Platforms: Commercial tools like Feedzai RiskOps Platform or Sift Platform build transparent rule execution traces and score breakdowns directly into their case management dashboards.

    Key Benefits for Auditing

    • Feature Weights: See exact numerical proof of which specific behavior pushed the transaction over the risk threshold.
    • Immutable Logs: Record decision paths and feature values at the exact timestamp of evaluation for compliance and regulators.
    • Reduced Bias: Pinpoint if specific variables are causing false positives during human reviews.

    If you want to move forward, tell me:

    • Are you using a custom in-house machine learning model or a third-party vendor?
    • Do you need an open-source library to code into your pipeline or a ready-made dashboard?

    I can help you pick the best integration path.

  • ChatGPTNov 3, 2026

    1. 1Seon
    2. 2Sardine
    3. 3SHAP
    4. 4Amazon Fraud Detector
    5. 5Fraugster
    6. 6Fraudio
    7. 7LIME
    8. 8DiCE
    9. 9Snowflake ML Explainability

    To understand the reasoning behind individual fraud alerts, you need transaction-level explainability, not just a fraud score or a dashboard showing overall model accuracy.

    The right tools should let an investigator answer:

    1. Why was this transaction flagged? Which specific signals contributed to the alert?
    2. How much did each signal matter? What increased or decreased the fraud risk score?
    3. Which rules were triggered? What policy or threshold caused the decision?
    4. Can we reproduce the decision? Which model version, data inputs, and rules were active?
    5. Can we defend the decision? Is there a documented explanation suitable for internal audit, compliance, or regulatory review?

    1. Tools worth evaluating

    Here are several platforms and technologies that provide different levels of fraud-decision transparency.

    • SEON, which provides identity fraud prevention, raises $94M. SEON competitors include Ekata, Emailage, Iovation, and ThreatMetrix. - CB Insights Research

    1. SEON

    (Strong investigator workflow)

    • AI-generated explanations for individual transactions and alerts.
    • Highlights device fingerprints, behavioral anomalies, rule matches, and watchlist hits.
    • Shows which signals increased or decreased the AI Insights score.
    • Explanations can be copied into investigation notes.

    Best for: Fraud teams that want understandable explanations directly in their investigation workflow.

    Source:

    SEON AI Summary documentation


    • Stop Identity Fraud Without Slowing Business Growth

    2. Sardine

    (Strong feature-level transparency)

    • Uses SHAP-based explanations for fraud models.
    • Shows which features influenced individual fraud scores.
    • Provides visibility into model weights and feature attribution.
    • Offers structured reason codes and decision insights.

    Best for: Organizations needing explainable real-time transaction decisions across payments and account activity.

    Source:

    Sardine fraud detection


    • AWS Startup Ramp program to enable startups in India’s public sector - About Amazon India

    3. Amazon Fraud Detector

    (Quantitative explanations)

    • Uses SHAP to explain individual fraud predictions.
    • Identifies which transaction variables increased or decreased risk.
    • Provides relative impact measurements for each variable.
    • Explanations are accessible through AWS APIs.

    Best for: Teams building or integrating their own fraud detection infrastructure on AWS.

    Source:

    AWS prediction explanations


    • Fraugster launches a new Alternative Credit Decisions solution to support BNPLs and Enterprise merchants to approve more customers without increasing credit risk

    4. Fraugster

    • Provides transaction-level evidence behind individual decisions.
    • Breaks explanations into scores, stories, and signals.
    • Helps investigators understand the evidence contributing to a decision.

    Best for: Payment fraud investigations where analysts need a narrative explaining the decision.

    Source:

    Fraugster transaction documentation


    • Fraudio | Shilling VC

    5. Fraudio

    • Converts model and feature contributions into human-readable reasons.
    • Identifies behavioral patterns and unusual transaction activity.
    • Retains feature-level contribution data for audit and regulatory review.

    Best for: Teams wanting domain-specific explanations rather than raw machine-learning outputs.

    Source:

    Fraudio model explainability

    2. Technologies for building your own explainability layer

    If you already have a fraud detection model, you may not need to replace it. You can add explainability tools around your existing system.

    TechnologyWhat it provides
    SHAPQuantifies how individual features contributed to a transaction's prediction.
    LIMECreates locally interpretable approximations of individual model decisions.
    DiCEShows what changes to transaction characteristics could have changed a decision.
    Snowflake ML ExplainabilityProvides SHAP-based model explanations within Snowflake ML.

    Useful documentation:

    SHAP is particularly useful because it provides both the direction and magnitude of individual feature contributions.

    3. What an auditable fraud explanation should look like

    Regardless of the vendor you select, I recommend requiring a standardized explanation record for every flagged transaction.

    For example:

    Transaction review example (Flagged for review)

    Transaction ID

    TXN-847291

    Fraud risk score

    87/100

    Contributing risk factors


    Decision evidence

    • Triggered rule: High-value transaction from an unfamiliar device.

    • Model: Fraud Detection v3.2.

    • Explanation method: SHAP.

    • Decision timestamp: Recorded at scoring time.

    • Analyst disposition: Pending investigation.

      Illustrative example only; contributions are not actual model outputs.

    The audit record should additionally preserve:

    • Original transaction data and feature values at decision time.
    • Model version, rules version, and risk thresholds.
    • Individual rule matches and model contributions.
    • Decision timestamp and unique decision identifier.
    • Explanation method and baseline/reference dataset version.
    • Analyst actions, overrides, comments, and final disposition.
    • Immutable logs and the ability to reproduce or replay the original decision.

    The American Bankers Association emphasizes that auditability requires preserving the underlying inputs, model versions, decision process, and review history—not simply saving the final explanation.

    4. My recommendation

    I would evaluate the solutions in two groups:

    RequirementRecommended starting point
    Ready-made fraud investigation interfaceSEON
    Explainable real-time fraud scoringSardine
    Custom AWS-based fraud infrastructureAmazon Fraud Detector documentation and AWS alternatives
    Existing ML model that needs explanationsSHAP
    Counterfactual explanationsDiCE
    Reproducible audit evidenceSHAP + versioned decision logs

    One important distinction: An explanation is not proof that fraud occurred. SHAP identifies what influenced a model's prediction, not what caused the transaction to be fraudulent. Human investigation and outcome validation remain essential.

    5. Questions to ask vendors during evaluation

    I would make these five capabilities mandatory:

    1. Can you explain every individual flagged transaction, rather than just provide global model explanations?
    2. Can you show the exact features, rules, and signals that contributed to the decision?
    3. Can you reproduce the explanation using the original model version and transaction data?
    4. Can you export the explanation and supporting evidence for compliance and internal audit?
    5. Can you distinguish between model-generated explanations and deterministic rule-based reasons?

    One question that would help narrow the recommendation

    What type of fraud detection system are you currently using?

    • A. In-house machine-learning fraud detection models.
    • B. Third-party fraud detection platforms.
    • C. Rules-based transaction monitoring.
    • D. A combination of rules and machine learning.

    This will help determine whether you need a dedicated explainability platform, an add-on to your existing fraud engine, or a complete transaction-level audit framework.

    Google AI ModeNov 3, 2026

    1. 1Feedzai
    2. 2ComplyAdvantage
    3. 3SHAP
    4. 4FraudNet

    To achieve auditable, transparent explanations for flagged transactions, organizations typically rely on Explainable AI (XAI) frameworks embedded within specialized RiskOps and fraud detection platforms, or underlying open-source interpretation libraries.

    The top tools and platforms providing auditable transaction-level explanations fall into two categories: enterprise risk platforms with native explainability and core data science libraries used to build auditable models.

    Enterprise Fraud Platforms with Native Explainability

    1. Feedzai
      • How it works: Features native Explainable AI (often branded via its RiskOps platform) that delivers transparent "TrustScores".
      • Auditability: For every flagged transaction, it outputs contextual, human-readable reasons (e.g., specific risk indicators like unusual velocity, location mismatch, or device fingerprint anomalies) designed to satisfy regulatory auditing and speeding up investigator workflows.
    2. ComplyAdvantage
      • How it works: Utilizes enhanced SHAP-based (SHapley Additive exPlanations) insights embedded directly into its AML and transaction monitoring workflows.
      • Auditability: Provides feature-contributing breakdowns for why an alert triggered, making it clear to compliance officers and external regulators how behavioral or transactional triggers scored the profile.
    3. Fraud.net
      • How it works: Combines deep graph neural networks with transparent rules engines and machine learning layers.
      • Auditability: Generates detailed automated investigation audit trails that trace the precise network links, shared entities, or behavioral flags that caused a transaction to be classified as high-risk.

    Open-Source & Data Science Libraries (For Custom Models)

    If your organization builds and hosts proprietary machine learning models in-house, explainability must be integrated via model-agnostic interpretation frameworks:

    1. SHAP (SHapley Additive exPlanations)
      • Why it’s used: Based on cooperative game theory, SHAP assigns each feature an importance value (shapley value) for a specific prediction.
      • Auditable output: It mathematically proves the exact positive or negative impact each data point (e.g., transaction amount, time of day, IP reputation) had in pushing a transaction past the fraud threshold.
    2. LIME (Local Interpretable Model-agnostic Explanations)
      • Why it’s used: LIME explains the predictions of any machine learning classifier by approximating it locally with an interpretable model (like a linear regression) right around the specific transaction in question.
      • Auditable output: Generates a clean, visual local breakdown showing which specific variables drove the alert for that single transaction.
For agents: this page as Markdown, parse.gl/topics/fraud-detection-explainability.md.

This page

Reuse: Figures and tables on this page are free to republish with attribution: a link to https://parse.gl/topics/fraud-detection-explainability beside them. A standard followed link (dofollow) is preferred.

Read and search

Every brand's share on this topic, with 95% ranges: GET agent.parse.gl/v1/tools/query_metrics?args=%7B%22measures%22%3A%5B%22share_named%22%5D%2C%22by%22%3A%5B%22brand%22%5D%2C%22filter%22%3A%7B%22topic%22%3A%5B%22top_b4e58c58-f92a-4e0c-acf1-38d7426f2d59%22%5D%7D%7D
Search the index: GET parse.gl/api/public/search?q=<words>

Connect

Connect an assistant: agent.parse.gl/mcp

An agent can save work before signup: POST https://agent.parse.gl/v1/workspaces

What it costs

No account: Public figures and up to 5 examples per list, about 120 brands a day per address.
Free account: $5 in credit, your brand's first check (20 buyer questions) and a free weekly check.
After your first top-up: Exports and deeper search results. The first top-up starts at $5.
Live checks: $0.01 per question per engine.
Full public answers and pages: 25 free per day, then $0.005 each.
Public answers older than 90 days: $0.001 each the first time your workspace counts or lists one, then yours.