Server data from the Official MCP Registry
Check a store or product page for scam, dropshipping and dark-pattern signals, paid per check
About
Check a store or product page for scam, dropshipping and dark-pattern signals, paid per check
Security Report
Valid MCP server (1 strong, 1 medium validity signals). 1 known CVE in dependencies ⚠️ Package registry links to a different repository than scanned source. Imported from the Official MCP Registry. 1 finding(s) downgraded by scanner intelligence.
6 files analyzed · 2 issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
Permissions Required
This plugin requests these system permissions. Most are normal for its category.
What You'll Need
Set these up before or after installing:
Environment variable: UNFRET_MCP_KEYPAIR
Environment variable: UNFRET_MCP_MAX_PRICE_USD
Environment variable: UNFRET_MCP_SESSION_CAP_USD
Environment variable: UNFRET_MCP_NETWORK
How to Install
Add this to your MCP configuration file:
{
"mcpServers": {
"unfret-mcp": {
"command": "uvx",
"args": [
"unfret-mcp"
],
"env": {
"UNFRET_MCP_KEYPAIR": "your-unfret-mcp-keypair-here",
"UNFRET_MCP_NETWORK": "your-unfret-mcp-network-here",
"UNFRET_MCP_MAX_PRICE_USD": "your-unfret-mcp-max-price-usd-here",
"UNFRET_MCP_SESSION_CAP_USD": "your-unfret-mcp-session-cap-usd-here"
}
}
}
}Some servers take additional arguments. See the repository for details.
Documentation
View on GitHubFrom the project's GitHub README.
Unfret
Unfret scores e-commerce product pages for scam and dropshipping signals. A browser extension sends the HTML of the page the user is viewing; the backend runs a LangGraph pipeline of independent analysis "skills" in parallel, and a small trained model turns their features into a calibrated 0–100 reliability score; an LLM writes the one-line explanation from the signals that moved it.
POST /v1/analyze → { "score": 18, "explanation": "New domain, AliExpress-sourced images and templated 5-star reviews." }
Project status: live, run by one person. Unfret runs at unfret.net with the Chrome extension, prepaid checks (card via Polar, or USDC/SOL with a Solana wallet) and pay-per-check x402 for AI agents. It is a side project: no SLA, and scores are a signal, not a verdict (see Limitations).
How it works
flowchart LR
A[POST /v1/analyze] --> P[preprocess<br/><sub>PageFacts + text, one parse</sub>]
P --> C{classify<br/><sub>rules first: known marketplaces<br/>and platforms, page facts; LLM for the rest</sub>}
C -- article / non-product --> X[early exit<br/><sub>score = -1</sub>]
C -- marketplace listing / storefront --> PR
C -. p2p ad .-> PP
C -. service provider .-> SV
subgraph PR [product subgraph]
S[cheap skills<br/><sub>in parallel</sub>] --> T{triage} -- photo check worth it --> R[reverse_image] --> T
T --> J[judge<br/><sub>scorer + LLM headline</sub>]
end
subgraph PP [p2p subgraph]
S2[skills for ads] --> T2{photo check} --> J2[ad rules]
end
subgraph SV [service subgraph]
S3[skills for service providers] --> T3{triage<br/><sub>rules</sub>} --> J3[judge<br/><sub>hand-written rules</sub>]
end
Preprocessing parses the page once into typed PageFacts (title, brand, prices, seller, rating histogram, dated
reviews, hidden text, checkboxes, timers, VAT IDs, policy links, and the business facts: public product IDs,
payment methods, published phone numbers and e-mail addresses, addresses, KvK and licence numbers, founding claims,
Organization/LocalBusiness data, same-site links, a service company's testimonials, a platform profile's track
record, …); a browser extension can send them directly (page_facts).
Contacts and addresses are read only from what the business publishes (structured data, tel:/mailto: links, the
footer and contact, legal or imprint sections), never from forms, account menus, checkout or delivery areas, so
nothing about the visitor ends up in the facts (facts/business.py). Each skill reads the facts and reports numeric
features plus factual findings (evidence, never a verdict). All page content is passed to the LLM as clearly
delimited untrusted data.
One shared classify step, one LangGraph subgraph per page class. preprocess and classify are shared; each
page class then runs in its own subgraph (src/unfret/graph/__init__.py), which fans out to the skills whose
page_types include the page's type (LangGraph's Send API, so they run concurrently), then a triage, then a judge:
- product (marketplace listings and storefronts): the cheap skills, the triage (rules first, the LLM only for unclear cases) that decides whether the reverse image search is worth it, and the judge (the trained scorer's band; an LLM writes the headline).
- p2p (
p2p_listing: a private seller's ad on Marktplaats, 2dehands, Vinted, Craigslist, Facebook Marketplace, or a private seller on eBay) and service (service_listing: a provider's profile on Werkspot, Thumbtack, Angi, HomeAdvisor, …;service_site: a service company's own website). These exist only whileUNFRET_EXPANSION_CLASSESis on (default off: classification is then exactly as before, and such pages are treated as they always were). No scorer is trained for them yet:- ads get a full verdict from cautious hand-written rules (
src/unfret/shopper_p2p.py): "Looks fine" only when nothing fired and the positives are concrete (an account of two years or more, well rated, and the platform's payment protection, pickup or a checked normal price); "many warning signs" only for strong combinations (payment pushed off the platform with a new or copied seller, or a bait price; a photo from other ads with a bait price); "some warning signs" for one serious sign or two middling ones; "a few things to check" otherwise. The photo check (reverse image) runs whenever the ad has a photo, within the per-analysis budget. - service providers get a full verdict from cautious hand-written rules (
graph/services.py), for the Netherlands and the US: "many warning signs" only for the combinations behind fake local businesses (town landing pages without an address plus links to other sites with the same phone numbers or tracking IDs; a premium-rate number plus payment up front or cash only; copied photos plus one of those or a brand-new site), "some warning signs" for one serious or two medium signals, "looks fine" only with concrete positives (an established domain, a complete identity with KvK or licence number, a street address, no doorway pattern, no upfront or cash-only terms; on a platform, two years and twenty reviews averaging four stars), and "a few things to check" otherwise. Their triage runs the photo search, by rules, when the cheap skills found something copied photos would confirm. No register is looked up (no KvK API, Companies House or state licence boards): the signals come from the page itself, the fingerprint store and the photo index, plus VIES for a VAT number. Their results carry no share token.
- ads get a full verdict from cautious hand-written rules (
Classification is rules first. A known marketplace's product page (Amazon, bol.com, Walmart) or a page with a
product and a price is settled from the facts. With the expansion classes on, a host and path table
(graph/platforms.py) comes first: a listing or profile on a known peer-to-peer or service platform is classified
without the LLM (an eBay listing by a seller the page labels a business stays a marketplace listing; otherwise it is
an ad), and the platform's other pages (search, home) go to the LLM rather than count as a shop; after the product
rules, structured data naming a trade (Plumber, Locksmith, HomeAndConstructionBusiness, …) makes a
service_site. The LLM classifies whatever is left, with the new types in its prompt only while the flag is on.
Nodes that call the LLM or fetch outside data (classify, the content, reviews, domain_age, eu_registry and
reverse_image skills, the triage, the judge) have LangGraph's built-in RetryPolicy: a transient error (dropped
connection, provider 5xx, rate limit) gets UNFRET_GRAPH_RETRY_ATTEMPTS attempts (default 2) before a skill counts
as unavailable. LangGraph, langchain-core and langchain-openai are pinned to their minor release and upgraded
deliberately; no LangSmith or other hosted LangChain service is used (its tracing is forced off).
POST /v1/analyze/stream streams every class's skill steps (astream(..., subgraphs=True)).
| Skill | What it checks |
|---|---|
content | Every class: one LLM read of the page text: scam copy and fake urgency, generic white-label product, whether the brand is established, implausible claims, missing trust information |
listing | Generated-looking brand names, inflated "was" prices, keyword-stuffed titles, seller ≠ brand, ships from China |
reviews | Reviews per day since the listing appeared, rating shape, duplicate and very short reviews, bursts, and review/title embedding similarity (reviews borrowed from other products) |
html_source_signals | Known dropship apps, supplier CDNs, AliExpress review importers, shipping-protection and countdown apps |
dark_patterns | Product pages and service sites: countdown timers (and whether they reset per visitor), pre-ticked paid add-ons, fee wording, and checkout total vs listed price when the checkout page is supplied |
injection | Every class: hidden text and instructions addressed to an AI, which honest shops have no reason to include |
eu_registry | Storefronts and service sites: VAT ID checked against the EU VIES register (name match) and its check digit (a number that can't exist earns no credit and makes the verdict "careful" at best; a bank account that starts like a VAT ID is ignored), withdrawal right and imprint; outside the EU (a US shop, or one on a non-European country domain or currency) a named company or US business address counts as its imprint, and a missing imprint, VAT ID or return policy is not applicable (neutral), since no law there requires them |
us_identity | US storefronts and service sites: a named company (LLC, Inc.), a US business address and phone number; an address that is only a mailbox (PO Box, PMB). Not in the scorer yet |
shop_policies | Storefronts: delivery ranges of 15+ days, returns sent abroad, a return address given only on request, restocking fees above 20%, and "Made in USA" on goods shipped from overseas. Not in the scorer yet |
domain_age | Storefronts and service sites: domain registration via RDAP and the first certificate in the CT logs; a "since 1998" / "founded 20 years ago" claim about the shop itself on a domain younger than a year by both measures (claims vs facts) |
shop_links | Storefronts and service sites: other web shops (or service sites) with the same analytics/pixel IDs, payment account or (hashed) contact details, one hop, from the shop fingerprint store; how many of them are young (their own registration dates). Service sites are recorded like shops and also linked on their published phone numbers (national formats too) and their e-mail domain (not webmail), hashed: one call centre behind many "local" brands. Local lookup, also in the quick tier; not in the scorer yet |
payment_methods | Storefronts: only payments that can't be reversed (bank transfer, crypto, Western Union, MoneyGram; gift cards don't count alone) and no card, PayPal, iDEAL, Klarna or other protected method in the text, logo alt texts or a payment provider's script (Shopify shops never: their checkout takes cards); protected methods offered (a positive). Not in the scorer yet |
claims | Storefronts: claims against the facts: "a Dutch company", "family business in Amsterdam", "based in Germany" while every address the shop gives is in another country (told from the address text: country names, Dutch postcodes, US state and ZIP, UK postcodes; no geocoding); "visit our showroom" with no address, postcode or phone number anywhere. Not in the scorer yet |
market_price | Product pages with a barcode (GTIN/EAN): the price against each other shop's median price for the same barcode over 90 days, from Unfret's own anonymous observations (unfret.market_prices); far below means at most 40% of the median of at least three other shops in the same currency. Off in evaluation; not in the scorer yet |
review_copies | Product pages: the longer reviews (60+ characters, 10+ words) whose normalised text other shops show too, from the review fingerprint store (unfret.review_store: hashes only). Told to the shopper only for an unknown brand with other resale signs, since brands syndicate reviews to their resellers. Off in evaluation; not in the scorer yet |
brand_presence | Product pages: the brand on Wikidata (a business or brand item with that label or alias) and its own <brand>.com/.nl in RDAP (registered, and how long ago), both cached as store-level facts. "No presence" is told to the shopper only on marketplace listings with other white-label signs. A network lookup: off in evaluation; not in the scorer yet |
safety_gate | Product pages: the product in the EU Safety Gate alerts (dangerous non-food products), from the vendored index: the barcode exactly, or the brand and a whole model number (5+ characters with a letter and a digit, or 6+ digits) in the title, model, MPN or SKU. Local; not in the scorer yet |
service_identity | Service sites, NL and US: what the site says about who it is. NL: a KvK number (Dutch businesses must show it on their website) of eight digits, a VAT number, the company name and legal form, a street address; US: the company name, a street address, and a licence number when the site says it is licensed ("says licensed but shows no licence number", never "unlicensed"); two different company names on one site. Nothing is looked up |
doorway_pages | Service sites: landing pages for five or more towns ("Loodgieter Utrecht", "Plumber Austin", from the site's own links) with no street address, and whether its only number is a central one (national, toll-free, premium): the classic fake local business |
service_terms | Service sites and profiles: payment in full or a deposit of half or more before the work, cash only, a call-out fee of (almost) nothing, a price set only on the doorstep, prices only on request, "24/7, there within 30 minutes", a premium-rate (0900, 1-900) number; a written quote or fixed price as the positive |
testimonials | Service sites and profiles: testimonials (on a platform, its reviews) that repeat each other with a town or name swapped, all 5 stars, repeated or placeholder names, dates within a week |
platform_profile | Platform profiles (Werkspot, Thumbtack, Angi, …): member since, jobs completed, rating and count, badges, response rate, as the platform shows them |
seller_profile | Ads: the seller's account as the platform shows it (never the name): a new account (under 90 days), no ratings, low ratings, no verification on a new account, many ads on a young account, slow replies; and the positives (two years or more, well rated, verified) |
off_platform | Ads: wording that takes the deal off the platform, in Dutch and English, over the ad's own text (not the platform's safety tips): contact by WhatsApp, Telegram, phone or e-mail; payment by bank transfer or payment link (not when paid at pickup), gift cards, crypto, money transfer or payment apps; a deposit or payment up front; "shipping only, no pickup"; "I'm abroad / on a ship"; refusing the platform's payment. Payments the ad rules out ("never pay in advance") don't count. Each finding quotes the ad; the content read adds its own judgement (content.off_platform_push) |
price_outlier | Ads: the asking price against the same product new (an ad naming a barcode: the median shop price in market_prices over 90 days, at least two shops) or against a conservative floor for the goods non-delivery ads use most (recent phones, consoles, laptops, graphics cards) and rentals; accessories, broken items, swaps, wanted ads and starting bids are never compared |
duplicate_ads | Ads: the same ad text (a simhash of its words) or the same phone number or e-mail address (keyed hash) in other ads checked in the last 90 days, from the ad store (src/unfret/ad_store.py: hashes, the platform and the day only; no seller, text or URL) |
reverse_image | Every class (ads whenever they have a photo; service providers when their triage's rules call for it, on the first photo that isn't a logo): the main photo in Unfret's own image index: the same photo on other shops, or in the ABO catalogue; for an ad also in other ads (a copied ad, or someone else's photo of the item). pHash, dHash, a DINOv2-small embedding (run locally) and a colour grid must all agree; own shop and same listing ignored; stock images skipped. See docs/image-index.md. Deep tier only; not in the scorer yet |
The skills from payment_methods on (and domain_age's founding claim, shop_links's shared address) report new
features that the shipped scorer doesn't use: they reach the shopper as reasons and positives, and the scores stay
exactly as they were until the scorer is retrained with them (evals.train already reads them; the store and lookup
skills stay out of training, like domain_age).
EU Safety Gate data. src/unfret/safety_gate_index.json.gz is a compact index of the alerts in the Commission's
Safety Gate weekly reports (XML list,
the "Weekly Reports - XML format" distribution of the data.europa.eu dataset
rapex-rapid-alert-system-non-food,
licence CC0 1.0, published by DG Justice and Consumers): alert number, case number, date, brand, product name, model,
barcodes, kind of product, risk type and level, for the alerts a page can be matched on (2005 to now). make safety-gate adds the weekly reports it lacks (reports never change once published); the monthly "Vendored data"
workflow runs make safety-gate-check, which fails once a new report is out, so the refresh lands as a PR.
Adding a skill
class ShippingTimeSkill(Skill):
name = "shipping_time"
description = "Flags multi-week shipping estimates."
features = ("weeks",)
async def run(self, state: AnalysisState) -> SkillOutput:
weeks = ... # from state["facts"] / state["cleaned_content"]
return self.output({"weeks": weeks}, [Observation(type="shipping", evidence=f"Ships in {weeks} weeks.")])
Register an instance in SKILLS in src/unfret/graph/__init__.py. Its
page_types decide which page classes run it (default: product pages; ANALYSED_PAGES, P2P_PAGES,
SERVICE_PAGES, SERVICE_SITES in graph/skills/__init__.py), and retry = True marks one that calls the LLM or
fetches outside data, so transient errors are retried.
API
Interactive docs are served at /docs. /v1/analyze* and /v1/credits take Authorization: Bearer <session token>.
| Method | Path | Description |
|---|---|---|
GET | /v1/auth/nonce | Start a Sign-In With Solana: nonce and message fields |
POST | /v1/auth/verify | Finish it: {address, signed_message, signature} → session token (30 days) |
POST | /v1/analyze | Analyse a page, paid from credits: { "url", "page_content"?, "page_facts"?, "checkout_content"? } |
POST | /v1/analyze/stream | The same, streamed as server-sent events (page_type, finding…, result) |
GET | /v1/credits | The signed-in wallet's balance |
GET | /v1/pricing | The price of a check, x402 prices, the packs (by card and with crypto), VAT rules, hot wallet |
POST | /v1/credits/purchase-tx | Unsigned SOL or USDC transfer that buys a pack (VAT included), plus a Solana Pay link |
GET | /v1/credits/solana-pay.svg | The same purchase as a Solana Pay QR code |
GET | /v1/credits/quotes/{id} | Whether a crypto purchase is paid; with its X-Unfret-Claim, its invite codes once |
POST | /v1/invites/redeem | Redeem an invite {code} for the signed-in new wallet or API key: 3 checks |
GET | /v1/schema/page-facts | JSON schema of PageFacts, for clients that extract facts themselves |
GET | /v1/showcase | /v1/showcase/{id} | "Spotted recently": published operator-run checks, see below |
POST | /v1/shares/preview | /v1/shares | Share a result as a link, anonymously (no Authorization), see below |
GET DELETE | /v1/shares/{id} | A shared result; delete it with X-Delete-Code |
POST | /v1/shares/{id}/object | A shop owner's objection: hides the shared result until reviewed |
GET | /v1/health | Liveness probe |
GET | /v1/health/ready | Readiness probe (checks the database; reports x402 and credits status, hot wallet balances, alerts) |
POST | /v1/check | Pay-per-check for AI agents over x402, see below |
GET | /llms.txt | /.well-known/x402 | Machine-readable description of /v1/check, its tiers and prices |
Credits (browser extension and platforms)
There are no accounts. A wallet signs in by signing a plain-text SIWS
message (no spending rights; the nonce is stateless and expires in five minutes) and gets a session token. The only
user state stored is wallet → balance in micro-dollars (and whether it redeemed an invite): no emails, no
purchase history (the chain is the ledger), no record of what was analysed.
Pricing. One setting, UNFRET_PRICE_PER_CHECK_USD ($0.20), sets every price: an analysis costs one check in
credits, an x402 deep check costs one check, and credits are sold in packs of 25, 50 and 100 checks
(src/unfret/credits/packs.py). A pack's price is its card price ($6, $11.50, $22: the pack's value plus the card
provider's worst-case cut of 6.5% + $0.50, rounded up to $0.50, before the provider's sales tax/VAT); paying with SOL
or USDC costs less, just the pack's value ($5, $10, $20) plus VAT where it applies. The card price is shown as the
price and crypto as the discount, never as a card surcharge (EU rules forbid surcharging consumer card payments).
Either way the account is credited the pack's value, so a check costs the same in credits however it was bought.
Visitors from the euro area (Cloudflare's country hint) pay by card in euros instead: €5.50, €10, €19
(UNFRET_CARD_PRICES_EUR, set by hand rather than converted, before VAT like the dollar prices). Dutch visitors
also get a "Pay with iDEAL | Wero" button above the card one (see Local payment methods below).
VAT on crypto purchases (src/unfret/credits/vat.py). The buyer states their country; the checkout prefills it
from Cloudflare's CF-IPCountry, trusted only when Caddy saw the request come from Cloudflare's edge (it forwards
that peer as X-Edge-Peer, checked against the vendored ranges). The IP address is never stored or logged. With
UNFRET_VAT_MODE=nl_under_threshold (default, while EU cross-border sales stay under €10,000 a year) every EU buyer
pays Dutch VAT (21%) and everyone else none; per_country uses each member state's standard rate, vendored from the
EU's TEDB (make vat-rates-check compares it and the Cloudflare ranges with their sources, run monthly by
.forgejo/workflows/vat-rates.yaml, which fails naming the changed file and the script that rewrites it; the
service logs vat_rates_stale 45 days after the table was last rewritten). Card
purchases are sold by the payment provider, which handles their tax.
Buying. /v1/credits/purchase-tx (and the Solana Pay QR) prices a pack for the buyer's country and stores that as
a quote; the transaction's memo is unfret:quote:<id>, so the scanner credits the right account (the payer, another
wallet, or an API key) and records the right VAT. /checkout does it from a
browser wallet or a phone. A background scanner walks the hot wallet's finalized transactions (a second one its USDC
account) and credits every incoming transfer, top-level or inside a program call: what arrived (USDC at face value,
SOL at its dollar value at crediting time, Pyth SOL/USD, rounded down; it waits rather than guesses while the price is
stale) minus its VAT. Each credit leaves a sales record (day, country, net, rate, VAT, asset, amount, signature; no
IP, no wallet column) in the same database transaction, kept ten years; GET /v1/admin/sales/<YYYY-Qn> exports a
quarter as CSV. A transfer without a quote, a manual one, counts as a sale to an unknown country at the Dutch rate;
the older unfret:credit:<beneficiary> memo still names who gets it. The cursor moves by compare-and-swap, so each
transfer is credited exactly once. Sweeps, fees and x402 settlements are ignored.
/connect signs a wallet in and hands the session to the browser extension
(window.postMessage, relayed by the extension's content script). Both pages are static HTML and vanilla JS with a
strict Content Security Policy: no framework, no third-party requests, Wallet Standard discovery written directly. An analysis costs one check ($0.20),
taken atomically before it runs and refunded when the page can't be analysed (score -1) or the analysis fails.
/check is the link checker for phones and browsers without the extension: it
sends only the link (POST /v1/analyze/stream with {"url"}), the server fetches the page itself before charging,
and a page it can't read (an error, a shop that refuses automatic visitors, a bot check, an empty shell that needs a
browser) is a free 422 that the page shows as such, never as a verdict. It installs as a web app with an Android
share target; the sign-in or API key is kept in the browser until sign-out, and there is no history.
There is no free trial: every new wallet or API key starts at zero checks and buys a pack. Grant an API key credit by
hand (support, a store reviewer's test checks) with POST /v1/admin/keys/<key_id>/grant and {"usd_micros": n}, at
most $10 a grant, with the admin token.
Invites (src/unfret/credits/invites.py): every credited pack comes with invite codes to give away, one per 25
checks (25 → 1, 50 → 2, 100 → 4), each worth 3 checks, so the 25-pack brings 28 checks in all. An account that never
had any credit (a wallet we've never credited, an API key never topped up) redeems one, once, with its own sign-in
(POST /v1/invites/redeem). Only each code's SHA-256 is stored, with the day issued and the day redeemed: no buyer,
no redeemer, no IP. The buyer sees the codes once: the purchase comes with a random claim token (never on chain or
sent to the card provider, stored only hashed); the codes are kept with the quote or card checkout until the first
status request carrying that token takes them and wipes them in one statement. Invites are a gift: no VAT, no sales
record. GET /v1/admin/invites counts those outstanding.
Card payments for API keys (Polar)
API keys can also be topped up by card through Polar, the Merchant of Record: Polar sells the pack,
collects the buyer's details and sales tax/VAT, and issues the invoice; this service only learns that a key was paid
for (src/unfret/credits/polar.py, src/unfret/credits/fiat.py). Card payments are off (/v1/pricing says
fiat.available: false, /v1/credits/fiat-checkout answers 503, readiness says "fiat": "off") until all of these
are set:
| Variable | |
|---|---|
UNFRET_POLAR_ACCESS_TOKEN | An Organization Access Token (Polar → Settings → Developers) with the single scope checkouts:write. Nothing else is called: no product, order, customer or refund reads |
UNFRET_POLAR_ENVIRONMENT | production (https://api.polar.sh, real money) or sandbox (https://sandbox-api.polar.sh; the default, also when empty). The token, products and webhook must come from the same environment |
UNFRET_POLAR_PRODUCTS | The Polar product of every pack: 25=<product id>,50=<product id>,100=<product id> |
UNFRET_FIAT_WEBHOOK_SECRET | The webhook endpoint's whsec_… secret |
In Polar: one one-time product per pack, priced at the pack's card price in USD before tax ($6.00, $11.50,
$22.00 at $0.20 a check), plus a second price in EUR equal to UNFRET_CARD_PRICES_EUR (€5.50, €10.00, €19.00;
keep USD as the organisation's default currency). A checkout is created for the pack's product with currency: "usd", or "eur" for visitors from the euro area (or when the page asks for it), discount codes off, our account id
(key:<id>) and this site's address (UNFRET_PUBLIC_BASE_URL) in its metadata and /checkout?paid=1 as the success
URL; nothing about the buyer is sent. If Polar answers with another currency or price, the checkout is refused before
anyone pays; a refused euro checkout falls back to the dollar one (logged as fiat_checkout_eur_fallback), so a
product still missing its euro price costs euro-area buyers iDEAL | Wero, not the sale.
Local payment methods (src/unfret/credits/local_methods.py). Polar picks the methods its checkout shows from
the checkout's currency and the buyer's billing country, and with no country it shows cards only: iDEAL | Wero
appears only on a EUR checkout whose billing country is the Netherlands. So a visitor whose country has an entry in
LOCAL_METHODS (today only NL → wero, "iDEAL | Wero", billing country NL, eur) gets a second button on
/checkout, and its checkout is created in that currency with customer_billing_address: {"country": "NL"}
prefilled (Polar's AddressInput needs only the country; checked on dev: the checkout still asks for the country
only, require_billing_address stays false). Polar's page then shows an iDEAL | Wero tab next to the card tab
(the card tab is still selected first; the API has no way to preselect a method). The buyer can still change the
country on Polar's page. Nothing else differs: the same products,
prices, metadata, crediting and refunds. /v1/pricing says which method a visitor gets (local_payment_method), so
the page has no country list of its own. To add a country, add one entry to LOCAL_METHODS (visitor country →
method id, button label, billing country, currency), but first check by hand that Polar really offers that method:
create a checkout in that currency, set that billing country on Polar's page and look. An entry for a method Polar
doesn't show there would only put a card form behind a button that promises something else.
Webhook: add an endpoint at https://<host>/v1/webhooks/fiat (format Raw), subscribed to order.paid,
order.refunded, refund.created and refund.updated. A paid order is credited the pack's value once,
and only if it is for a configured pack's product at exactly that pack's card price before tax (net_amount) in the
order's currency (USD, or EUR at the pack's euro price; the currency is kept in fiat_payments.currency); anything else credits nothing and logs polar_order_not_credited (order id, reason, currency and
amount; never the buyer) for a person to sort out in Polar. Refunds take back the refunded share of the credits
(refunded_amount, before tax); a refund that settles a dispute Polar lost takes back the whole order. Polar has no
webhook for disputes themselves. Other events are acknowledged and ignored.
Dev and production in one Polar organisation: each site gets its own webhook endpoint (and secret), and Polar
sends every order to both. A site credits only orders whose checkout it made (its own checkout record, or the
metadata's site); another site's order answers other_site and leaves no trace (no balance, no payment row).
"Spotted recently": the showcase
No demo data: the site shows real checks of real product pages, run by the operator and each
reviewed by the owner before it is published (unfret.showcase, migration 13). Never a user's check: a case is
always a fresh server-side check of a public page (the same fetch_page + full graph path as a URL-only check,
without any account or charge), and the showcase_cases table has no column that could hold an account, payer or
report. A case stores the product title, the shop's host, the product URL, when it was checked, the analysis
response as a paying user gets it (without balance or report token) and optionally a screenshot (in the row, at most
800 kB, since the container's files go with each deploy). It is a draft until published; removed takes it down
for good, keeps the reason and drops the screenshot.
make showcase ARGS="add https://shop.example/product" # the server fetches and checks it: a draft
make showcase ARGS="list --status draft"
make showcase ARGS="show 3" # incl. exactly what the public would see
make showcase ARGS="screenshot 3 shot.png" # optional: PNG, JPEG or WebP
make showcase ARGS="publish 3"
make showcase ARGS="remove 3 --reason 'shop owner asked'"
The CLI talks to the running service's admin API (/v1/admin/showcase…, UNFRET_URL and the admin token as for
make reports). In make reports, when a label agrees with the model, p promotes the page: only its address is
sent, and the server checks it again as the operator; nothing from the report goes into the case.
The public sees published cases only: GET /v1/showcase (newest first, Cache-Control: public, max-age=300), a
"Spotted recently" section on / and /check, and a page per case, /showcase/{id}, in the link checker's
presentation (the same renderer, static/check-render.js). Each case shows the day it was checked ("the page may
have changed since"), the shop, a rel="nofollow noopener" link to the product page, the screenshot if any, and a
route for shop owners to object. The wording is factual: the bands are phrased as what Unfret would tell a shopper
about the listing ("Unfret would warn you about this listing"), there is no score, and the words "scam" and "fraud"
never appear (a headline or quote containing one is left out; show lists what was).
Sharing a result
A shopper can make their own check public as a link (unfret.shares, migration 16), and nothing on it says who
they are. Every assessed result carries a share_token: an HMAC over the product address (without fragment,
credentials and tracking parameters), a hash of the result as a share shows it, whether the check included the
checkout page, the product title and an expiry (7 days). It names no account. POST /v1/shares/preview shows
exactly what would be public; POST /v1/shares stores it. Both are sent without Authorization (a request with
one is refused) and the token must match the url and the result exactly, so a share can only show a verdict Unfret
really gave for that page. A check that included the checkout page is never shared.
What is public, and stored in shared_results: the showcase's wording of the verdict (no score, never "scam" or
"fraud"), without the page's own words (a reason whose detail quotes the page keeps only its title, a quoting
headline becomes the band's catalogue sentence, flags keep their labels but not their evidence), the product title,
the shop, the product link and the day of the check. Plus a SHA-256 hash of the delete code (shown once), the expiry
(90 days, on a day boundary) and, after an objection, why it is hidden. No account, wallet, IP address, time of day
or view count; expired rows go in the hourly housekeeping. Limits: 20 shares per visitor network per day (in
memory) and a daily cap.
/r/{id} shows it in the link checker's presentation (the showcase renderer): "Checked by an Unfret user on …; the
page may have changed", a nofollow link to the product, X-Robots-Tag: noindex and a robots meta tag. The sharer
deletes it with DELETE /v1/shares/{id} and X-Delete-Code; a shop owner's POST /v1/shares/{id}/object hides it
at once, and the operator reviews it under the admin token: GET /v1/admin/shares (hidden ones),
POST /v1/admin/shares/{id}/unhide, DELETE /v1/admin/shares/{id}. On /check, "Share this result" shows the
preview, then shares through the phone's share sheet or copies the link, and shows the delete code once.
Pay-per-check for agents (x402)
POST /v1/check takes {url, page_content?, tier: quick|deep, policy: strict|balanced|lenient} and is paid per call
over x402 v2 with the exact scheme on Solana, in wSOL (wrapped SOL) or USDC. Without a
PAYMENT-SIGNATURE header it answers 402 with a PAYMENT-REQUIRED header listing wSOL first, then USDC. The client
signs a transaction that pays the price into the hot wallet's token account for that mint: a plain TransferChecked from a standard
wallet, or a smart wallet (Squads and other program-controlled wallets) paying by CPI. Unfret co-signs as fee
payer with the same hot wallet (agents pay only the price: quick $0.01, deep one check, $0.20), submits it and waits
for confirmation (upfront flow), then runs the analysis and answers with {action: allow|warn|block, risk_score, confidence, flags, model_version, …} plus PAYMENT-RESPONSE, scored by the trained scorer. warn means "ask your
human". Under balanced and lenient an agent is never warned about a page a shopper would see as "reliable" or
"concerns" (the band); strict warns from risk 0.25 whatever the band. A page that can't be fetched is refused
before any money moves. Nothing about the payment or the page is stored.
The two tiers (QUICK_SKILLS in src/unfret/x402/verdict.py; each 402 option says what it buys in
extra.includes, as do /.well-known/x402 and /llms.txt):
| quick ($0.01) | deep ($0.20) | |
|---|---|---|
| What runs | The page itself, by rules: listing, pricing (on-page discount checks, no price history), html_source_signals, dark_patterns, injection, eu_registry (no VIES), us_identity, shop_policies, shop_links (our own fingerprint store) | Everything: the same analysis as /v1/analyze and the extension, adding the LLM read (content), reviews, reverse_image, the price history, domain_age and VIES |
| LLM / image index | Never (classification by rules: a page without a product and a price is not assessed, and refunded) | Yes |
| Scorer | model-quick.json, trained on the quick features only (evals.train --quick, variant C) | model.json |
| TEST (333 pages) | AUC 0.746 (US 0.782, EU 0.673; storefronts 0.769); legit flagged 29/143; recall 0.60 | AUC 0.894 (US 0.964, EU 0.828; storefronts 0.836); legit flagged 25/143; recall 0.82 |
Quick is a first-pass filter: it catches what a page shows by itself (dropshipping and review-import apps, fake discounts, timers, pre-ticked add-ons, text aimed at AI, missing legal information, dropshipping terms), and misses what only reading the listing, its reviews or its photo reveals. Check what matters with deep.
Each accepts option names the network in CAIP-2 form (solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1 on devnet), as do
/.well-known/x402 (network, with the cluster name in network_name) and /llms.txt. Its extra carries the
mint's decimals (9 for wSOL, 6 for USDC), quoteToleranceBps (how far a payment may be from this quote: 200 for
wSOL, 0 for USDC; clients should re-fetch the 402 right before paying), constraints (below) and feeCapNote:
constraints.maxPriorityFeeLamports is in lamports on every option, USDC included, because the hot wallet pays the
fee in SOL; it is UNFRET_X402_MAX_PRIORITY_FEE_BPS of the tier's dollar price converted at the SOL/USD quote. A
refused payment answers 402 again with error saying why; when the simulation failed (simulation_failed) it adds
reason, a short cause derived from the simulation's error and logs: insufficient_funds,
source_token_account_missing, mint_mismatch, owner_mismatch, account_not_found, blockhash_not_found, the
error class in snake case (invalid_account_data) or custom_program_error_<code> for another program's own error.
Documentation truncated — see the full README on GitHub.
Reviews
No reviews yet
Be the first to review this server!
More Developer Tools MCP Servers
Rea
Freeby Morluto · Developer Tools
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Paperclip
Freeby Paperclipai · Developer Tools
Trending hip-hop artist momentum scores across four cultural dimensions.
Scrapling
Freeby D4Vinci · Developer Tools
Web scraping with stealth HTTP, real browsers, and Cloudflare bypass. CSS selectors supported.
Git
Freeby Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.
