DEV Community: Yantrix

A one-line access check that silently checked nothing

Yantrix — Thu, 27 Aug 2026 15:10:55 +0000

What a real security review finds in a codebase that looked fine.

The setup

We ran Yantrix cold against shadcn-ui/taxonomy — a real, widely-used Next.js + Prisma + NextAuth reference application with almost 20,000 GitHub stars, no special access, no hints, exactly the way a customer's security team would approach a codebase they'd never seen before.

Two functions handle deleting and editing a blog post:

export async function DELETE(req, context) {
  if (!(await verifyCurrentUserHasAccessToPost(params.postId))) {
    return new Response(null, { status: 403 })
  }
  await db.post.delete({ where: { id: params.postId } })
  ...
}

This looks correct. There's a dedicated function, named exactly what it does, called before every mutation. A reviewer skimming this file would move on.

What's actually inside the check

async function verifyCurrentUserHasAccessToPost(postId: string) {
  const session = await getServerSession(authOptions)

  const count = await db.post.count({
    where: {
      id: postId,
      authorId: session?.user.id,
    },
  })

  return count > 0
}

When there's no active session, session?.user.id evaluates to undefined. Prisma's query engine treats a field set to undefined in a where clause as "this field wasn't specified" — not "match nothing." The query that actually runs is:

db.post.count({ where: { id: postId } })

The ownership check is gone. If the post exists at all, count comes back 1, count > 0 is true, and an unauthenticated request is told it has access to someone else's post.

Why this one is worth naming specifically

Every field in this function reads as intentional access control — the name, the placement, the shape of the check. Nothing about it looks like a gap. The failure is entirely in what one ORM does with one specific value, which happens to be the opposite of what the code visibly appears to be checking for. It's exactly the kind of finding that survives a normal code review, because a normal code review is reading for intent, and the intent here was correct — the implementation just didn't do what it looks like it does.

This is also not a one-off. The same shape — a field derived from an optional session, dropped straight into a where clause with no guard in front of it — is common enough across Next.js + Prisma codebases that it's worth a deliberate check for, not something to catch by accident.

The part worth being honest about

This exact bug class turned out to be hard for general-purpose AI reasoning to catch reliably, even for a capable model given the whole file. Across repeated real runs, it required the model to already know a narrow, specific fact about Prisma's own behavior — not a security concept, an ORM implementation detail. When that fact wasn't already primed, the model looked at the code and reasonably concluded the check was fine.

That's the finding that shaped how this is built: this specific pattern is now caught by a deterministic check, not left to chance on whether reasoning happens to recall the right ORM trivia in the moment. Some things need a model that can reason about intent. Some things need a narrow, permanent, always-on check that doesn't forget. Knowing which is which — and building both — is the actual engineering problem, not just running an LLM over a diff.

What this means for a codebase getting ready for scrutiny

A vendor security review, an enterprise procurement questionnaire, or acquisition due diligence isn't looking for typos. It's looking for exactly this shape of thing — code that reads correctly and isn't. The value isn't in flagging more issues. It's in finding the ones that would actually surface when someone official is looking, before they do.

Full methodology — 21 real codebases, 17 risk categories, verified ground-truth recall — at yantrix.ai. The repository's owner has closed both issues and pull requests on this project — respected here rather than worked around. The fix shown above is preserved as a public commit at yantrix-ai/taxonomy, for anyone who wants to verify it directly.

I built a 58-tool MCP server where AI agents pay per call in USDC — here's how

Yantrix — Wed, 25 Mar 2026 20:18:04 +0000

For the past few weeks I've been building Yantrix — an agent-native API network where every tool call costs fractions of a cent in USDC, settled automatically on Base mainnet via x402.
Today it hit 58 tools and I want to share what I learned.

What is x402?
x402 is an emerging standard that revives the HTTP 402 "Payment Required" status code. When an agent calls a paid endpoint without payment, it gets back a 402 with instructions on how to pay. An x402-enabled client automatically signs a USDC microtransaction and retries — no credit cards, no API key billing, no invoices.
The economics: $0.001 per call. Agents can autonomously consume APIs and pay for them. No human in the loop.

What Yantrix covers
The 58 tools span 7 service groups:
Crypto — real-time price, trading signals, deep analysis, AI reports
Finance — stocks, company profiles, financials, forex, market overview
Web Extract — clean text, metadata, contacts, PDF, structured data, AI summaries
India Business — GST lookup, MCA21/CIN, business enrichment (this is a real gap in the market)
Agent Utility — Indic script transliteration (9 scripts), IFSC lookup, phone validation, timezone, pincode
Agent Registry — register agents with capabilities and DIDs, discover other agents
Agent Session — stateful workflow sessions with spend caps and call tracking

The architecture that makes it work
Each service is a single Python file. FastAPI + asyncpg + eth-account. Deployed on Railway. Here's the full pattern:
python# Single-file Railway service — no core/ dependency hell
import os, asyncpg
from fastapi import FastAPI
from contextlib import asynccontextmanager

DATABASE_URL = os.getenv("DATABASE_URL")
PORT = int(os.getenv("PORT", 8000))

_pool = None

async def get_pool():
global _pool
if _pool is None and DATABASE_URL:
_pool = await asyncpg.create_pool(DATABASE_URL, min_size=1, max_size=10)
return _pool

@asynccontextmanager
async def lifespan(app):
await run_migrations()
yield
if _pool: await _pool.close()

app = FastAPI(lifespan=lifespan)

if name == "main":
import uvicorn
uvicorn.run("main:app", host="0.0.0.0", port=PORT)
Key lesson: self-contained single files deploy reliably. I wasted days trying to share a core/ library across services in a monorepo. Railway builds each service in isolation — relative paths break. Single file = no path issues.

TrustLayer — every response is ECDSA signed
This is the part I'm most proud of. Every API response includes a _trust envelope:
json{
"data": { ... },
"_trust": {
"call_id": "ytx_abc123",
"endpoint": "/v1/agents/register",
"payload_hash": "sha256:def456...",
"timestamp": 1711234567,
"signer": "0x41A024...",
"signature": "0x3ad7f1..."
}
}
Agents can verify this signature cryptographically:
pythonfrom eth_account import Account
from eth_account.messages import encode_defunct

message = f"{call_id}:{endpoint}:sha256:{payload_hash}:{timestamp}"
msg = encode_defunct(text=message)
recovered = Account.recover_message(msg, signature=signature)
assert recovered.lower() == expected_signer.lower()
No other API marketplace does this. When an agent makes a decision based on data from Yantrix, there's cryptographic proof of what data it was given.

The MCP server is dynamic
Instead of hardcoding 58 tools in a TypeScript file, the MCP server fetches a registry JSON at startup:
typescriptconst REGISTRY_URL = "https://registry.yantrix.ai/mcp-registry.json";

// On startup, fetch all tools dynamically
const registry = await fetch(REGISTRY_URL).then(r => r.json());
// New APIs appear automatically on next host restart
This means adding a new API requires zero npm publishes. Update the registry JSON, done.

Agent Registry — agents registering themselves
The newest addition is an agent registry where AI agents can register their own capabilities:
bashcurl -X POST https://agent-registry.yantrix.ai/v1/agents/register \
-H "Content-Type: application/json" \
-d '{
"name": "GSTIN Intelligence Agent",
"endpoint_url": "https://my-agent.railway.app",
"wallet_address": "0x...",
"capabilities": [{
"name": "gstin_lookup",
"category": "data_enrichment",
"price_usdc": 0.001
}]
}'
Returns an agent_id and a W3C DID (did:yantrix:). Other agents can discover it:
bashGET /v1/agents/?capability=gstin_lookup&status=active
This is the foundation for agent-to-agent commerce — Relay, the next layer I'm building.

Agent Session — tracking multi-step workflows
For workflows that make multiple API calls, sessions track everything:
bash# Create session with $1 spend cap
POST /v1/sessions/
{"ttl_seconds": 3600, "max_spend_usdc": 1.0}

Record each call

POST /v1/sessions/{id}/calls
{"service": "udbavam", "endpoint": "/v1/gstin", "price_usdc": 0.002}

Get analytics

GET /v1/sessions/{id}/analytics

→ {total_calls: 47, total_spend_usdc: 0.094, success_rate: 97.8}

Sessions auto-abort if the spend cap is hit. No surprise charges.

How to use it
Install the MCP server:
bashnpx @yantrixai/mcp
Or add to Claude Desktop:
json{
"mcpServers": {
"yantrix": {
"command": "npx",
"args": ["@yantrixai/mcp"]
}
}
}
All 58 tools are available immediately. Paid tools return a x402_payment_required response until you configure an x402-enabled wallet.
Full API reference: https://yantrix.ai/llms.txt

What's next
Yantrix Relay — agent-to-agent micropayment mesh. When Agent A needs something Agent B offers, Yantrix brokers and settles in USDC. I take 2-5% of every settlement. Currently building the Capability Discovery and Settlement Record services.
TrustLayer Protocol — spinning out the ECDSA signing as an open standard. Any API provider can implement it. trustlayer-verify npm package coming soon.

If you're building with AI agents and want to try x402 micropayments, the registry is at https://registry.yantrix.ai/mcp-registry.json and everything is open at https://github.com/yantrix-ai.
Happy to answer questions about the x402 implementation, the Railway single-file pattern, or the agent registry design.

Tags: #ai #python #web3 #agents #mcp #x402 #blockchain #api[]

Built 17 x402-gated APIs + a dynamic MCP package as a solo indie dev — here's everything

Yantrix — Sat, 21 Mar 2026 11:49:11 +0000

What I built

Over the past few weeks I shipped 17 production APIs — all x402/USDC micropayment gated,
all MCP compatible, all deployed on Railway under my own domain yantrix.ai.

Here's the full list:

API	What it does	Price
groundtruth.yantrix.ai	Fact verification for agents	$0.002–$0.020
memex.yantrix.ai	Persistent agent memory	$0.001–$0.005
indic.yantrix.ai	Indian language NLP (9 scripts)	$0.001–$0.008
contractscan.yantrix.ai	Contract risk analysis	$0.005–$0.025
threatmodel.yantrix.ai	STRIDE threat modelling	$0.005–$0.025
signal.yantrix.ai	AI trend intelligence	$0.005–$0.020
compwatch.yantrix.ai	Competitor intelligence	$0.010–$0.020
examforge.yantrix.ai	Exam generator	$0.005–$0.020
voiceprint.yantrix.ai	Writing style transfer	$0.003–$0.010
papertrail.yantrix.ai	Indian regulatory intel	$0.003–$0.015
ratelord.yantrix.ai	Rate limit coordinator	$0.0005–$0.001
heatmap.yantrix.ai	API usage analytics	$0.0001–$0.015
debateclub.yantrix.ai	Argument generator	$0.003–$0.010
callsight.yantrix.ai	Sales call intelligence	$0.010–$0.025
phonevalidator.yantrix.ai	Global phone validation	$0.001
ifsclookup.yantrix.ai	Indian bank IFSC lookup	$0.001
timezonedetective.yantrix.ai	Timezone detection	$0.001–$0.002

What is x402?

x402 is an open payment protocol by Coinbase built on HTTP 402 "Payment Required".
Instead of API keys and billing dashboards, agents pay per call using USDC on Base.
No accounts. No monthly invoices. Just pay and get the resource.

Agent calls API → gets 402 with payment terms → pays USDC → gets response

The MCP package

Instead of building a static MCP server, I built a dynamic one.

The package fetches its tool list from a live registry at startup:

npx @praveen030686/yantrix-mcp

When I add a new API, I update one JSON file on the server. All users get the
new tool automatically on next restart. No npm republish ever needed.

Adding a new API takes 10 lines

# In mcp-registry/main.py, add to TOOLS list:
{
    "name": "new_tool",
    "service": "newapi",
    "endpoint": "https://newapi.yantrix.ai/endpoint",
    "method": "POST",
    "description": "What it does.",
    "input_schema": {...},
    "cost_usdc": "0.005",
    "category": "category",
}
# git push → Railway redeploys → users get new tool automatically

Tech stack

Backend: FastAPI (Python 3.11)
Payments: x402 + USDC on Base Mainnet
AI: Claude API (Sonnet + Haiku)
Deployment: Railway (one service per API)
MCP: TypeScript MCP SDK
Domain: Spaceship + custom subdomains per API

Claude Desktop config

{
  "mcpServers": {
    "yantrix": {
      "command": "npx",
      "args": ["@praveen030686/yantrix-mcp"],
      "env": {
        "DEV_MODE": "true"
      }
    }
  }
}

I Built 3 APIs With 22 Paid Endpoints That AI Agents Pay For Automatically — Here's How (x402 + USDC on Base)

Yantrix — Sun, 08 Mar 2026 07:50:58 +0000

Liquid syntax error: 'raw' tag was never closed

How I Built a Crypto Data API That AI Agents Pay For (x402 + Express.js

Yantrix — Sat, 07 Mar 2026 02:20:10 +0000

What I Built

A crypto data enrichment API where AI agents pay USDC micropayments per request on Base mainnet.

The Problem

Traditional APIs need subscriptions, API keys, billing systems. AI agents can't sign up for accounts autonomously.

The Solution

x402 protocol — agents discover my API, pay $0.01-$0.10 USDC per request, get data instantly. No signup, no API keys.

Three Endpoints

/api/v1/price/{symbol} → $0.01 — real-time price data
/api/v1/signal/{symbol} → $0.05 — BUY/HOLD/SELL trading signal
/api/v1/deep-analysis/{symbol} → $0.10 — full analysis with risk assessment

Tech Stack

Express.js + @x402/express
@coinbase/x402 for CDP facilitator auth
USDC on Base (eip155:8453)
Deployed on Railway ($5/month)

How It Works

Agent requests data
Server returns HTTP 402 with payment instructions
Agent signs USDC transfer, retries with payment proof
Server verifies via CDP facilitator, returns data
USDC lands in my wallet

Try It

API: https://crypto-enrich.up.railway.app
MCP config: https://crypto-enrich.up.railway.app/.well-known/mcp.json

Cost to Build

$5/month hosting. That's it. 88-90% profit margins.