Forem: manja316

Building a free Polymarket screener: how I turned 13,963 markets into a single scannable page

manja316 — Tue, 26 May 2026 10:51:37 +0000

Polymarket has thousands of markets. Their UI is built for depth on a single market — bet slip, orderbook, charts — not for scanning across the universe. If you want to ask "what dropped 20pp overnight" or "which crypto markets are sub-20¢ with real volume," there's no built-in view.

So I built one. It's free, it's static, it rebuilds from the public Gamma API every few hours, and the source is on GitHub. This post is how it works.

The data layer

The Polymarket Gamma API (https://gamma-api.polymarket.com/markets) is paginated and unauthenticated. The "active universe" is much smaller than the lifetime market count Polymarket advertises:

import requests

def fetch_active_markets():
    out, offset = [], 0
    while True:
        r = requests.get(
            "https://gamma-api.polymarket.com/markets",
            params={"closed": "false", "limit": 500, "offset": offset},
            timeout=30,
        ).json()
        if not r:
            break
        out.extend(r)
        offset += 500
    return out

That pulls ~1,200 currently-tradable markets in 3 paginated calls. The other ~12,800 indexed are resolved or expired — useful for backtesting but not for a "what's moving now" screener.

Ranking: movers vs volume

Two top-of-page lists:

Top 24h movers: sorted by abs(one_day_change) descending, filtered to volume24hr > 1000 to drop dust.

Volume leaders: sorted by volume24hr descending. Mostly the same 8-10 megamarkets day-to-day (election props, BTC year-end), which is exactly why you need the movers view.

Crash signal: one_day_change <= -0.15 — a proxy for "fell off a recent local high." Backtested on a separate dataset (5,629 events, see cross-signal-data) at 73% mean-reversion rate, but the live screener column is a proxy not the same signal — caveats are in the repo's methodology discussion.

Why static + GitHub Pages

The screener regenerates as a flat HTML file every few hours via a single Python script. No backend, no database, no auth, no costs. The whole site is docs/index.html + per-market detail pages + a small CSS file. Deploy = git push. Total hosting bill = $0.

The tradeoff: data is up to a few hours stale. For a screener that's a feature, not a bug — you're scanning for setups, not executing in microseconds.

What I'd build next (and won't, alone)

WebSocket layer for live price ticks on top of the static base
Open-interest column (not in Gamma; needs CLOB orderbook crawl)
Alerts: "ping me when any crypto market crosses 20pp overnight"
A "movers within volume" intersection view (asked about it in Discussion #5 — feedback welcome)

Try it

Live: https://luciferforge.github.io/polyscope/?utm_source=devto&utm_medium=article&utm_campaign=polyscope-week22
Source: https://github.com/LuciferForge/polyscope
Underlying historical dataset (separate $9 product if you want backtest data): https://manja8.gumroad.com/l/agyjd?utm_source=devto&utm_medium=article&utm_campaign=polyscope-week22

The screener itself stays free forever. The historical SQLite dataset (10.8M snapshots, 43+ days of depth) is what funds the hosting.

Every Indian GST invoice generator forces signup. I built one that doesn't.

manja316 — Thu, 21 May 2026 22:51:54 +0000

I needed to send one GST invoice last week. Took me 25 minutes.

Vyapar wanted me to sign up. Zoho Books wanted me to sign up. Tally wanted me to install desktop software and walked me through a 3-screen wizard. The Indian government's e-invoice portal needed an aadhaar OTP and a separate "tax payer login."

I just needed: enter buyer GSTIN + line items → PDF.

So I built it. Single page, runs in your browser, generates a compliant tax invoice in 60 seconds. Free, open source, no signup, no analytics on your form data.

Live demo: https://gst.protodex.io

Here's what's actually in it.

What a GST invoice needs (the bureaucratic part)

Rule 46 of the CGST Rules lists 16 mandatory fields. The interesting ones from a code perspective:

GSTIN of supplier and recipient (15 chars, format: 27ZYXWV9876E1A2)
HSN/SAC code per line item — 4 digits if your turnover ≤ ₹5cr, 6 digits if more
GST split: CGST + SGST if same state, IGST if different state
Place of supply — determines the split logic above

The split is where most calculators get it wrong. Naive implementation:

const tax = amount * gstPercent / 100;
const cgst = tax / 2;  // ← WRONG when seller != buyer state
const sgst = tax / 2;

Correct implementation:

const sameState = sellerStateCode === buyerStateCode;
const tax = amount * gstPercent / 100;
const cgst = sameState ? tax / 2 : 0;
const sgst = sameState ? tax / 2 : 0;
const igst = sameState ? 0 : tax;

If your seller is in Karnataka (KA) and your buyer is in Maharashtra (MH), it's IGST — a single tax that the Central government collects and redistributes. Same state: CGST + SGST, split equally between Central and State.

I bundled the top 40 HSN/SAC codes most SMBs and freelancers use (software dev 998314, hosting 998433, legal 998212, retail goods classes 8471 for computers, 6109 for T-shirts, etc.). Full official list is ~150k codes at cbic-gst.gov.in if you need an obscure category.

How the PDF gets generated (no server)

The PDF is built entirely client-side using jsPDF + the jspdf-autotable plugin. The whole pipeline:

import { jsPDF } from 'jspdf';
import 'jspdf-autotable';

const doc = new jsPDF({ unit: 'mm', format: 'a4' });
doc.text('TAX INVOICE', 105, 15, { align: 'center' });
doc.autoTable({
  startY: 60,
  head: [['Description', 'HSN', 'Qty', 'Rate', 'GST', 'Total']],
  body: lineItems.map(toRow),
});
doc.save('invoice.pdf');

No server, no upload, no API. Your invoice data never leaves the tab. Open DevTools → Network → you'll see zero requests after page load.

What I deliberately didn't build

GSTR-1 filing — that's a monthly compliance feature. Use Zoho/Vyapar.
E-invoice / IRN generation — mandatory only if turnover > ₹5cr. The handful of buyers above that threshold already use enterprise tools.
Recurring invoices — if you need this, you need accounting software anyway.
Server-side persistence — invoices auto-save to your browser's localStorage. Refresh-safe, machine-bound. Switch machines = re-enter once.

What I learned about Indian tax software

It's a market where the dominant tools (Tally, Zoho, Vyapar) compete on feature breadth and SaaS pricing, but they all skip the use case I had: "I send one invoice every other month and just want a PDF."

That's a long tail problem — too small for SaaS, too irregular for a Tally install, too compliance-heavy for a Word template. So everyone falls back to copy-pasting an Excel template they downloaded from a forum 3 years ago. Or hires a CA for what's a 60-second task.

The free no-signup tier is the right shape for that user.

What's next

Things on the roadmap if there's interest:

Logo upload (currently the PDF is text-only)
Save invoice history locally (right now localStorage keeps the form, not the past PDFs)
CSV export of line items for accounting handoff
e-Way bill generator for goods movement > ₹50k (separate compliance category)

Let me know which of these you'd actually use. If it's just "I need logo upload," I'll ship that this week.

Source / try it: https://gst.protodex.io

This is part of protodex.io — a small set of free utilities focused on Indian compliance + global dev work. Sister sites: property.protodex.io (Indian property total-cost calculator), cron.protodex.io (cron expression explainer with systemd timer output).

I rebuilt crontab.guru with three features I needed every week

manja316 — Wed, 20 May 2026 22:51:31 +0000

crontab.guru is one of the best small dev tools on the internet. It explains a cron expression in plain English instantly. I've used it for ~8 years.

But every time I came back, I wanted three things it doesn't do.

So I built them. Live at cron.protodex.io — same dark-mode style, single page, no signup, runs offline. Here's what's different.

1. Plain English → cron (the reverse direction)

crontab.guru is cron → English. Once you've written cron three times, you don't need the explanation. You need help going the other way: "I want this to run every weekday morning at 9 — what's the cron?"

I added a generator. Type "every 15 minutes during business hours" → get back */15 9-17 * * 1-5. It's not full natural language (I haven't gone to NLP), but the common patterns work: "every X minutes", "every X hours", "daily at HH:MM", "weekly on DAY at HH:MM", "monthly on day N".

2. Next 10 actual run times

When you're debugging "did my cron actually fire?" you want to see: "next run is in 47 minutes, then 4 hours from now, then..." Most cron tools show the expression but not the upcoming firings.

The naive approach — increment a Date by one minute, test each — works but dies on sparse schedules:

while (out.length < 10) {
  if (matchesAllFields(d)) out.push(new Date(d));
  d.setMinutes(d.getMinutes() + 1);
}

That works for */5 * * * * (every 5 min) but dies on @yearly — you'd walk 525,600 minutes (one year) just to find the second run. Slow on V8, times out in browser.

Smart-skip fixes it:

while (out.length < 10) {
  if (!matchesField(c.month, d.getMonth()+1)) {
    d.setMonth(d.getMonth() + 1, 1);  // jump to next month
    d.setHours(0, 0, 0, 0);
    continue;
  }
  if (!matchesField(c.dom, d.getDate())) {
    d.setDate(d.getDate() + 1);  // jump to next day
    d.setHours(0, 0, 0, 0);
    continue;
  }
  // ... same for hour, minute
  out.push(new Date(d));
  d.setMinutes(d.getMinutes() + 1);
}

@yearly now resolves in 3ms instead of timing out. Also correctly handles leap-year crons like 0 0 29 2 * — returns Feb 29 of 2028, 2032, 2036, 2040, 2044.

3. Systemd timer equivalent

Most modern Linux is systemd-first. Whenever I converted a cron job into a managed service, I had to mentally translate 0 9 * * 1-5 into:

[Timer]
OnCalendar=Mon..Fri *-*-* 09:00:00
Persistent=true
RandomizedDelaySec=30

[Install]
WantedBy=timers.target

The tool generates the full [Timer] block side-by-side with the cron explanation. With the sensible defaults baked in: Persistent=true (catch up on missed runs after reboot), RandomizedDelaySec=30 (avoid thundering herds on tight-fleet deploys).

What this is built on

Pure vanilla JS. No framework. No bundler. ~6KB minified. Source structure is two files: index.html (which has all the JS inline) and the shared protodex stylesheet.

Hosted on Cloudflare Pages free tier. Works offline once the page loads — there's no API call at runtime, the entire parser + describer + next-run calculator + systemd generator runs in your browser.

Edge cases I haven't handled

6-field Quartz format (with leading seconds) — only standard 5-field cron
Year field — some forks (e.g. Synology) accept a 6th year field. Not supported.
Named days with mixed numeric — MON-FRI,0,6 works in some implementations. Not here.

Patches welcome if anyone hits these.

Try it: cron.protodex.io

This is part of protodex.io — a small set of free tools focused on dev utilities and Indian compliance.

I built an airdrop scanner that tells crypto farmers how much they've already lost. Most see a number they don't like.

manja316 — Tue, 19 May 2026 12:30:57 +0000

Most airdrop tools are dishonest by design. They sell hype — "you're 92% eligible!" — and route you to bridges they get affiliate commissions on, with no signal at all about whether the bridging is actually worth your gas.

I spent the last few weeks building a different kind of scanner. The headline number on the overview tab isn't your eligibility score. It's the dollar amount you've already spent on gas across all your wallets and chains.

Try it (free, no signup, your keys never leave the browser): protodex.io/airdrop.html

The reality check most tools don't show you

I asked 12 friends running multi-wallet airdrop farms to scan their setups. Every single one was net negative on lifetime gas spent versus airdrop USD received. Including the people who got into Hyperliquid early.

The era when bridging once to Arbitrum got you UNI-tier money is over. Sybil filters have gotten aggressive (Berachain wiped 30–60% of farmed wallets, ZK was similar), per-wallet allocations are smaller, and mainnet ETH gas is brutal. So I built the tool I wanted, not the tool that sells better.

Three things this scanner does that I don't think others do:

1. Pairwise Sybil clustering detection

Protocols increasingly cluster wallets by day-overlap. If your 5 wallets all show activity on the same days — even if you tried to vary the transaction types — they look like one farmer to the allocator. The Berachain TGE filter explicitly used this signal.

I implemented a pairwise comparison: for each pair of wallets, count shared active days as a fraction of the smaller wallet's total activity. If overlap > 65%, surface a warning with the actual day count and a recommendation to stagger.

function detectSybilClusters(metrics, allAddrs) {
  const clusters = [];
  for (let i = 0; i < allAddrs.length; i++) {
    for (let j = i + 1; j < allAddrs.length; j++) {
      const daysA = new Set();
      const daysB = new Set();
      Object.values(metrics[allAddrs[i]] || {})
        .forEach(m => (m.daysList || []).forEach(d => daysA.add(d)));
      Object.values(metrics[allAddrs[j]] || {})
        .forEach(m => (m.daysList || []).forEach(d => daysB.add(d)));
      if (daysA.size < 5 || daysB.size < 5) continue;
      const overlap = [...daysA].filter(d => daysB.has(d)).length;
      const pct = overlap / Math.min(daysA.size, daysB.size);
      if (pct > 0.65) clusters.push({ /* ... */ });
    }
  }
  return clusters;
}

Not a perfect proxy for protocol-side clustering (they also use IP, transfer graph, behavioral fingerprints), but day-overlap is the easiest leak to detect locally and the easiest to fix.

2. Pattern-aware scoring, not volume-only

Volume-only scoring is exactly what Sybil farmers optimize for, and exactly what protocols penalize. So I added two multipliers on top of the base score:

Diversity multiplier: unique counterparties / 50, capped at 1.2x
Consistency multiplier: if activity spread > 30 days, +10%

function scoreProto(metrics, proto) {
  let total = 0;
  const breakdown = [];
  proto.criteria.forEach(c => {
    const v = metrics[proto.chain]?.[c.key] ?? 0;
    const pts = v >= c.t[3] ? c.pts
              : v >= c.t[2] ? Math.round(c.pts * 0.75)
              : v >= c.t[1] ? Math.round(c.pts * 0.5)
              : v >= c.t[0] ? Math.round(c.pts * 0.25)
              : 0;
    total += pts;
    breakdown.push({ label: c.label, val: v, pts, max: c.pts });
  });
  const cps = metrics[proto.chain]?.counterpartiesCount || 0;
  const spread = metrics[proto.chain]?.spread || 0;
  const diversityMult = Math.min(1.2, 1 + cps / 50);
  const consistencyMult = spread > 30 ? 1.1 : 1.0;
  return { score: Math.min(100, Math.round(total * diversityMult * consistencyMult)) };
}

So 500 transactions to one contract score worse than 200 transactions across 20 contracts. Which matches how actual allocations work.

3. Gas cost reality, in USD, headlined

Every outgoing transaction has gasUsed * gasPrice. Sum that across chains, multiply by live native-token prices from CoinGecko, surface in USD. That's the headline number.

Most users see a number they're not happy about. That's the point.

The tech stack

Whole thing is a single HTML file:

React 18 + Babel standalone via unpkg CDN — no build step, no bundler, no Vercel deployment dance
1,500 lines, ~83KB on the wire
Deploys to GitHub Pages on git push
localStorage for API keys + wallets (nothing touches my server)
CSP locked to explorer endpoints + CoinGecko + the email-capture form
Parallel batched scan (5 in-flight with Promise.allSettled and 429/503 backoff) → 3-wallet × 13-chain scan in ~30 seconds

Etherscan V2 unified API now covers most major EVM chains with one key. Sonicscan, Routescan (for Berachain), and Monad's testnet explorer get special-cased fallbacks.

I deliberately picked the single-HTML-file path over a full Next.js app because:

The trust signal of "this fits in one tab and I can audit it in 10 minutes" matters for a tool that handles your wallet history.
The protocol list will go stale fast — I'd rather edit a single file than rebuild a deploy.
No backend means I literally cannot collect your keys even if I wanted to.

What's curated for May 2026

Most of the "famous" airdrops have already happened. Listing them as "active opportunities" would be dishonest. So:

HYPE (Hyperliquid), BERA (Berachain), ZK (zkSync), SCR (Scroll), MODE, S (Sonic), INIT (Initia), ES (Eclipse), MON (Monad) — all dropped. Demoted to S2/S3 farming with realistic likelihood %.
Symbiotic, Mira Network, Etherealize, Monad testnet — actually pre-token, surfaced as S-tier.
HyperEVM, Berachain S2, Sonic S2, Linea LXP-L still farmable.

The list goes stale within weeks of any new TGE. Building a daily-cron registry update is the next thing on the list.

Honest about monetization

The bridge action items use affiliate-tracked URLs (deBridge, Orbiter, CoinDCX for the India onramp). They're labelled in the code; the source is public. The scanner stays free forever. There's no premium tier, no subscription, no "pro features coming soon."

The closest thing to a paywall is the email signup at the bottom for a weekly "airdrop reality check" newsletter. Optional.

What I'd love feedback on

The Sybil overlap threshold (65%) — too aggressive? too lax? I picked it from intuition + a couple of public TGE post-mortems. Empirical calibration would be better.
The scoring weights per protocol — heuristic. If you've actually been allocated by one of these protocols, your input on what mattered would improve the calibration.
Missing protocols — there are several pre-token plays I almost certainly missed. Drop names in comments.
Failure modes — if the scanner shows wrong data for your wallet, I want to know. Privacy is preserved (your data never reaches me) but I'd love a screenshot or paste of the per-criterion breakdown.

Source + live tool: protodex.io/airdrop.html

If you scan and find your gas number is depressing — you're not alone. Most farmers are net negative. That's the honest reality. Decide eyes-open from here.

Claude Code Skills Pack — 15 Production Skills, 5 Hooks, 7 Slash Commands ($99 lifetime)

manja316 — Tue, 19 May 2026 09:53:34 +0000

I've been running Claude Code as my daily IDE for 6+ months. The Anthropic docs are great, but going from "I installed it" to "I have a workflow that actually compounds across sessions" took ~200 hours of trial and error.

I packaged everything I learned. Today it's available as a single zip.

👉 skills.protodex.io — $99 lifetime, single-developer license, 7-day refund

What's in the pack

15 production skills — not toy examples, things I use weekly:

session-start-gate — 60-second orientation at session start (reads journal, git state, open todos, daemons)
commit-quality — writes real commit messages from your staged diff
pr-author — generates PR descriptions: summary, why, test plan, risks, rollback
diff-reviewer — pre-commit review for security, bugs, missing tests
test-gap-finder — finds missing test cases by branch analysis
dependency-safety — before any dep bump: changelog, CVEs, call-site impact
secret-scanner — high-confidence + heuristic patterns, triages false positives
onboarding-orient — land in a new repo, get a 1-page brief in 60s
flaky-test-detector — static analysis for time deps, randomness, race conditions
debug-systematic — four-phase root-cause protocol, no fix until cause is named
daily-digest — EOD: shipped, decided, blocked, next
dead-code-finder — language-aware tooling + false-positive triage
migration-planner — expand → migrate → contract → verify, kill switches each phase
config-doctor — audits settings.json, hooks, MCP servers, CLAUDE.md for issues
slash-command-builder — scaffolds new /commands from a brief

5 hooks that automate the boring parts:

session-start-brief — fires at session start, summarizes recent changes + git + todos
pre-commit-quality — scans staged diff for secrets and red flags before any commit
post-edit-summary — per-session edit log that survives context compaction
stop-event-handoff — when session ends, appends summary to journal (anti-amnesia)
subagent-stop-budget — tracks subagent invocations, warns at 75%, blocks at 100%

7 slash commands:

/ship /review /audit /triage /digest /orient /onboard-new-repo

1 battle-tested CLAUDE.md template — generalized from the operating manual that runs my own daily workflow.

A sample skill in full

Here's debug-systematic — the iron-law debug protocol I run every time something breaks:

# Debug Systematic

Iron law: no fixes until the root cause is named.
Most "fixes" are pattern-matched changes that suppress
one symptom and create two more.

## Four-phase protocol

### Phase 1 — Investigate (no hypotheses yet)

Goal: gather facts. Resist the urge to guess.

- Exact error message + full stack trace (copy verbatim)
- Reproduction steps — every time, or intermittent?
- Recent changes — last commit on affected path, last deploy time
- Environment — local? staging? prod?
- Frequency — first occurrence? regression? always-broken?
- Related signals — logs, metrics, recent alerts

If you don't have one of these facts, ASK before proceeding.

### Phase 2 — Analyze (build the timeline)

Map what should happen vs what does happen, step by step.
Identify the EXACT point where actual diverges from expected.

### Phase 3 — Hypothesize (then disprove)

State it precisely:
"The bug is caused by X because Y happens when Z."

Design the test that would DISPROVE it.
Run it. ONE hypothesis at a time.

### Phase 4 — Implement (only after RC is named)

The fix must:
1. Reference the named root cause in the commit message
2. Add a test that fails without the fix and passes with it
3. State the regression risk

If that's the quality bar you want for all 15 skills, the pack is for you. If it's not, don't buy.

Why it costs money

The whole pack is 32 files, ~60 KB zipped. I could open-source it and get GitHub stars. I'm not, because:

The free version would attract contributions of varying quality and dilute the bar. The pack works because every file has gone through real-world use.
$99 once means you actually install it and use it. Free downloads sit in your ~/Downloads/ forever.
Honest economics — I want to keep building these full-time. Selling beats begging for sponsorships.

Install in 5 minutes

Unzip into ~/.claude/
chmod +x ~/.claude/hooks/*.sh
Merge one block into ~/.claude/settings.json (full snippet in INSTALL.md)
Restart Claude Code

Full guide: INSTALL.md in the zip.

License

Single-developer license. Use on every machine YOU work on. Fork and modify freely. Don't redistribute the pack itself. Team license (up to 10 devs) is a separate listing.

Lifetime updates included — when I ship new skills, you get the new zip via your Gumroad library.

Refund

7 days, no questions. If it doesn't compound your workflow, email me and I refund.

👉 Buy on Gumroad — $99 lifetime

👉 Browse the full pitch at skills.protodex.io

Built by @manja316 · I maintain protodex.io, an index of 9,600+ MCP servers with security scores · I publish here daily.

If you have a skill you'd want in v2, drop a comment. Buyer suggestions go to the front of the queue.

Free Polymarket Dataset on Kaggle: 13,963 Active Markets + 100K Price Sample (May 2026)

manja316 — Tue, 19 May 2026 09:53:32 +0000

I just pushed a fresh sample of the Polymarket dataset to Kaggle. Free download, Apache 2.0, no email gate.

👉 https://www.kaggle.com/datasets/luciferforge/polymarket-markets-prices-sample-2026

What's in it

Two CSV files:

File	Rows	What it gives you
`markets.csv`	13,963	Every currently-active Polymarket market with question, category, volume, liquidity, status, end date, slug
`prices_sample.csv`	100,000	The most recent 15-minute price snapshots across the universe — preview of the full 10.8M-snapshot corpus

8 MB compressed. Loads instantly in pandas, DuckDB, Polars, or any spreadsheet.

What you can build in 20 minutes

A screener. Filter markets by category × volume × spread × days-to-resolution.
A volume leaderboard. markets.csv has volume, volumeNum, volume24hr — rank, sort, group by category.
A "lottery ticket" finder. Find low-price (<$0.10) outcomes with non-trivial liquidity. There are hundreds.
A category dashboard. What's the average spread in sports vs politics vs crypto? The CSV has the data.
A correlation map. Even with 100K snapshots, you can compute simple correlations between sub-markets in the same event (semi-final A vs final winner, for example).

What it's NOT

This is the sample, not the full historical corpus.

If you need:

Every 15-minute snapshot for 43+ days (10.8M+ rows)
Orderbook depth (1.07M+ snapshots)
The full SQLite database for joins
Continuous updates

...that's the $9 Polymarket Full Dataset on Gumroad. The Kaggle sample is the on-ramp.

How it was collected

Automated pipeline running 24/7 since March 2026:

Gamma API → market metadata + prices for every active market
CLOB API → orderbook depth (top 10 levels) for top 200 markets by volume
SQLite storage with indexed timestamps for analytical queries
Sample CSVs regenerated when the dataset is republished

Source: protodex.io — the MCP-server directory with security scores. I built the Polymarket collector to feed a separate trading bot project; the dataset is the byproduct.

Why a Kaggle release at all

Two reasons:

It's where the prediction-market quant crowd lives. Kaggle has a dedicated "prediction markets" search niche. The other dataset I have there (polymarket-historical-prices) is sitting at 68 downloads from zero promo. Putting structured data where researchers already are has been higher-leverage than waiting for Reddit posts to go viral.
Sample-to-paid funnels work. If you find an edge in the free sample, paying $9 for the full corpus is an easy yes. If the sample data is unusable to you, you'd never have bought $9 anyway. Aligns incentives.

Limitations to know

The 100K-row price sample is the most recent 100K snapshots only — not a uniform random sample across the full 43-day window.
"Active markets" here means markets that were live as of the last collection run. Resolved markets aren't included in markets.csv.
Polymarket pulled a few markets between the snapshot and publish. Cross-check by slug if you find any 404s.
The dataset is updated when I refresh it — not in real time. For live data, hit the Gamma API directly (it's free and rate-limited generously).

License

Apache 2.0. Use commercially, modify, redistribute. Credit Protodex if you publish derived work; no obligation otherwise.

What I'd love feedback on

If you download this and build something — even a half-finished notebook — drop a comment with what you tried. I'm watching which use cases come up so I know what the V2 corpus should prioritize (more orderbook depth? more historical reach? resolved-market history? a labeled crash-event dataset?).

The dataset is live now: Polymarket Markets + Price Sample (2026) on Kaggle.

If it's useful, an upvote on Kaggle helps it surface in the prediction-markets search — that's the only ask.

The anatomy of a single-purpose AI tool (and why I shipped two of them this week)

manja316 — Mon, 18 May 2026 22:51:09 +0000

I keep hitting the same friction with ChatGPT: I want to do ONE thing — fix this JSON, build that regex — and a chat window is the wrong shape for it. Too many turns, too much context-reset, too much typing.

So I built two tools that prove a smaller hypothesis: a single-purpose page with AI as the fallback beats a chat window for any task you do more than once a week.

The shape

Both apps are the same shape:

Deterministic path first. regexai runs your regex through native RegExp and highlights matches as you type. jsonfix calls JSON.parse and formats. No API, no latency, no cost. 95% of sessions never leave this path.
AI fallback. If the deterministic path fails (regex doesn't match what you want, JSON throws SyntaxError), one button hands the problem to Claude with a tight prompt. Result lands back in the same UI.
No login, no quota popup, no "sign up for more". Friction kills these utilities. The cost per session is low enough that I eat it.

Why this shape wins

Chat is bad at repeating chores because every turn re-establishes context. Single-purpose pages keep state in the URL or the textarea — paste, click, paste, click. You can do twenty in a row.

ChatGPT is great for novel problems. It's wrong for the 30th time this month you needed to validate an IPv4. The tool that wins for "30th time" is the one with the lowest activation energy, and that's a bookmarked URL that does ONE thing.

Architecture (small enough to fit in a tweet)

Next.js 16 App Router
One client component for the UI, one route handler for the AI call
@anthropic-ai/sdk on the server, claude-haiku-4-5 for speed and cost
Edge runtime so cold starts don't matter
Vercel analytics, nothing else

That's it. No database. No auth. No queue. The state of the app is whatever's in the textarea. If the tab closes, the work is gone — and that's correct, because the user is solving a 30-second problem, not building a project.

The prompt that does the heavy lifting

For jsonfix:

You are a JSON repair tool. The user pasted text they believe should be valid JSON but it isn't. Return the corrected JSON and a one-line explanation of what was broken. Output as {"fixed": "...", "explanation": "..."}. Do not invent fields. Preserve all keys and values; only fix syntax.

For regexai:

You are a regex builder. Given the user's description, return {"pattern": "...", "flags": "g", "explanation": "...", "testString": "..."}. Use ECMAScript regex syntax (no PCRE-only features). Generate a testString that demonstrates a match.

Both prompts are pinned: model name, system prompt, schema. No few-shot examples — the schema in the prompt is enough at this scope.

What I'd build next in this shape

Tools that are great candidates:

cron expression builder
SQL query explainer (paste a query, get the plain English)
diff explainer (paste two blobs, get a semantic summary)
HTTP request replayer (paste curl, get fetch / Python requests / etc.)

The pattern is the same every time: deterministic path, AI fallback, no login, one job per page.

Try them

If you build one in the same shape, drop the link — happy to feature it.

Every Indian GST invoice generator forces signup. I built one that doesn't.

manja316 — Mon, 18 May 2026 10:51:53 +0000

I needed to send one GST invoice last week. Took me 25 minutes.

I just needed: enter buyer GSTIN + line items → PDF.

So I built it. Single page, runs in your browser, generates a compliant tax invoice in 60 seconds. Free, open source, no signup, no analytics on your form data.

Live demo: https://gst.protodex.io

Here's what's actually in it.

What a GST invoice needs (the bureaucratic part)

Rule 46 of the CGST Rules lists 16 mandatory fields. The interesting ones from a code perspective:

GSTIN of supplier and recipient (15 chars, format: 27ZYXWV9876E1A2)
HSN/SAC code per line item — 4 digits if your turnover ≤ ₹5cr, 6 digits if more
GST split: CGST + SGST if same state, IGST if different state
Place of supply — determines the split logic above

The split is where most calculators get it wrong. Naive implementation:

const tax = amount * gstPercent / 100;
const cgst = tax / 2;  // ← WRONG when seller != buyer state
const sgst = tax / 2;

Correct implementation:

const sameState = sellerStateCode === buyerStateCode;
const tax = amount * gstPercent / 100;
const cgst = sameState ? tax / 2 : 0;
const sgst = sameState ? tax / 2 : 0;
const igst = sameState ? 0 : tax;

How the PDF gets generated (no server)

The PDF is built entirely client-side using jsPDF + the jspdf-autotable plugin. The whole pipeline:

import { jsPDF } from 'jspdf';
import 'jspdf-autotable';

const doc = new jsPDF({ unit: 'mm', format: 'a4' });
doc.text('TAX INVOICE', 105, 15, { align: 'center' });
doc.autoTable({
  startY: 60,
  head: [['Description', 'HSN', 'Qty', 'Rate', 'GST', 'Total']],
  body: lineItems.map(toRow),
});
doc.save('invoice.pdf');

No server, no upload, no API. Your invoice data never leaves the tab. Open DevTools → Network → you'll see zero requests after page load.

What I deliberately didn't build

GSTR-1 filing — that's a monthly compliance feature. Use Zoho/Vyapar.
E-invoice / IRN generation — mandatory only if turnover > ₹5cr. The handful of buyers above that threshold already use enterprise tools.
Recurring invoices — if you need this, you need accounting software anyway.
Server-side persistence — invoices auto-save to your browser's localStorage. Refresh-safe, machine-bound. Switch machines = re-enter once.

What I learned about Indian tax software

The free no-signup tier is the right shape for that user.

What's next

Things on the roadmap if there's interest:

Logo upload (currently the PDF is text-only)
Save invoice history locally (right now localStorage keeps the form, not the past PDFs)
CSV export of line items for accounting handoff
e-Way bill generator for goods movement > ₹50k (separate compliance category)

Let me know which of these you'd actually use. If it's just "I need logo upload," I'll ship that this week.

Source / try it: https://gst.protodex.io
This is part of protodex.io — a small set of free utilities focused on Indian compliance + global dev work. Sister sites: property.protodex.io (Indian property total-cost calculator), cron.protodex.io (cron expression explainer with systemd timer output), airdrop.protodex.io (free crypto airdrop scanner — relevant if you do any crypto on the side and need to track Schedule VDA disclosure).

Week 1 of pnl-truthteller: 22 pypi downloads, 0 stars, and one real bug report

manja316 — Mon, 18 May 2026 01:33:58 +0000

A week ago I shipped pnl-truthteller — a one-command auditor that reads a Polymarket wallet's on-chain fills and compares them against what the bot's own DB thinks it earned. The thesis: most trading bots overstate P&L by 5–15% because they log the post-order intent, not the matched fill.

I wrote up the launch in this article. This is the follow-up. Same project, one week later, all numbers.

The numbers (week 1)

Pulled from APIs at write time, not eyeballed:

pypi downloads — last 7d: 22
pypi downloads — last 30d: 276
github stars: 0
github forks: 0
github open issues: 0
gumroad sales of the optional dataset: 0
GitHub Discussions threads opened by real users: 1 (about partial-fill dedup — the genuinely hard part of the implementation)

That's a real number row, not a vibe. If you've shipped indie open-source you know how those numbers feel: not zero, not exciting, ambiguous. The honest read is "evidence the audience exists, no evidence it's a magnet yet."

What I'm calling success vs. noise

I committed before launch to a kill rule: four flat weeks in a row across all five channels and the project gets retired. Week 1 doesn't trigger it (no trend to flat against yet), but I'm logging the baseline publicly so I can't fudge it later.

What I'm watching:

Returning installs. 276/month on a tool with no marketing is mostly first-touch curiosity. The question is whether anyone runs it twice. pypistats doesn't expose that, so I'll proxy it with GitHub repo unique-visitor traffic and Discussions activity.
Slippage Index contributions. I asked for anonymized audit outputs to build a cross-operator dataset. n=1 so far (me). Goal n=10.
The category-bug claim landing. I pulled a random Polymarket wallet off the public CLOB and ran the audit cold — DB-equivalent +$32, on-chain −$30. Different bot, different strategy, same gap shape. If others repro this on their own wallets, the tool has a moat (it's not just my problem). That signal is the most valuable.

What I'd do differently if shipping week-1 again

Lead with the random-wallet audit, not the launch announcement. The category-bug evidence is more interesting than "I built a tool." I buried it in section 4 of the launch post. Should've been the title.
Default the CLI to --output=stdout instead of a markdown file. A surprising number of people opened the tool, saw it wanted a path, and bounced. Quietly painful UX miss.
Cut the optional Gumroad bundle from week 1. Free tool + paid dataset on day-one creates an "is this a sales funnel?" smell. Should've spent week 1 building trust and dropped the dataset week 3.

What's in the dataset (if you actually want it)

Five real Polymarket wallets, fully audited: per-trade DB-vs-onchain delta, slippage attribution (price vs. partial-fill vs. gas), and the raw CLOB fills as CSV. It's the input I used to validate the tool wasn't just confirming my own bias.

If that's useful — it's $19 on Gumroad. One-time, no subscription. The tool itself stays free and MIT.

Code, and the only ask

pip install pnl-truthteller
pnl-truthteller --wallet 0xYourProxyWallet --output report.md

If you run any bot on a CLOB-style venue (Polymarket, Kalshi, dydx, GMX-perps) and audit your own wallet, the only thing I'd ask is: drop the one number (P&L gap %) in Discussion #3. Zero is fine. Negative is also fine. I just want the distribution.

Week 2 retro lands next Saturday with these same metrics + week-over-week delta.

Give Claude (or Cursor) live Polymarket prediction-market data with one MCP server

manja316 — Tue, 12 May 2026 02:19:19 +0000

Give Claude (or Cursor) live Polymarket prediction-market data with one MCP server

Polymarket has a public API. Your AI agent — Claude Desktop, Cursor, Cline — does not speak it. So when you ask "what prediction markets just crashed?" the agent either makes something up, scrapes a stale wiki, or politely declines.

I got tired of that. polymarket-mcp-pro is a Model Context Protocol server that exposes seven read-only tools to any MCP-compatible client. The agent can list markets by volume, pull historical price snapshots, find recent crashes, and inspect order-book depth — all over a structured JSON tool surface, no HTTP code in your prompts.

It's free, open source, and backed by a real dataset (not a toy demo).

The numbers behind it

Stats refreshed 2026-05-25 — corpus now spans 58 days of continuous indexing. Markets: 13,964 → 15,355 (+10%); price snapshots: 10.8M → 15.1M (+40%) since first publish on 2026-05-12.

The MCP server is just the agent-facing skin. The data layer behind it is api.protodex.io, which indexes:

15,355 Polymarket markets
15.1M+ price snapshots (one every 15 minutes per active market)
$11.7B+ cumulative volume covered
Refreshed continuously, served via a stable REST surface

When you ask the agent "show me markets that dropped 15% in the last 4 hours," it's running against that whole corpus, not a 10-market sample.

Install in 30 seconds

If you have uv:

uvx --from polymarket-mcp-pro polymarket-mcp

Or, classic pip:

pip install polymarket-mcp-pro

The PyPI distribution name is polymarket-mcp-pro because the bare polymarket-mcp was taken by an unrelated package. The CLI and import path both stay polymarket_mcp.

Wire it into Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "polymarket": {
      "command": "uvx",
      "args": ["polymarket-mcp"]
    }
  }
}

Restart Claude Desktop. The polymarket tools appear in the tool picker.

Cursor: same JSON block under Settings → Features → MCP Servers. Cline, Continue, any other MCP client over stdio: same command.

The seven tools

Tool	What it does
`get_stats`	Dataset-wide counts and freshness
`list_markets`	Paginated list with category, search, sort
`get_market`	Single market detail with CLOB token ids
`get_prices`	Historical price snapshots for a Yes/No outcome
`get_crashes`	Markets that dropped >= N% in the last H hours
`get_categories`	Category breakdown with market counts and volume
`get_orderbook`	Live bid/ask depth for a CLOB token id

Everything is read-only. There is no order placement, no signing, no wallet. The agent observes; you decide.

What I actually use it for

Three workflows, real not hypothetical:

1. Crash scanner as a morning routine. "Run get_crashes with threshold 15% over 4 hours, filter to volume > $100k, summarize the top 5." The agent comes back with a structured list and a paragraph each on what each market is. Most days zero matches. Some days something interesting.

2. Researching a news event. When something happens in the world that has prediction markets — election, ruling, central-bank meeting — I ask the agent to pull every related market plus its 24h price action. The agent picks the right markets via search; the data is fresh because it's queried at prompt time, not from training data.

3. Building strategy notes. I keep a Markdown file of strategy hypotheses. The agent appends "current state" sections by calling the tools — "as of this query, the resolution market for X is trading at Y with Z volume in the last day." No copy-paste from a Polymarket browser tab.

Why this isn't just a thin wrapper

A thin wrapper would forward the agent's question to Polymarket's CLOB API and call it a day. Two problems with that:

The CLOB API is rate-limited and returns raw orderbook diffs. An agent burning tokens decoding diff sequences is wasteful.
There is no historical price endpoint on the live API. If you want price 18 hours ago, you have to maintain your own snapshot pipeline.

polymarket-mcp-pro talks to api.protodex.io, which has been running that snapshot pipeline since early 2026. The historical depth (15.1M+ points) is the thing the agent gets that no thin-wrapper alternative provides.

What's coming in v0.2

A WebSocket subscription transport. Right now get_crashes is poll-based — the agent asks, the server returns the current snapshot. v0.2 will let the agent subscribe to a stream and get pushed updates when a crash threshold is breached, without re-asking. The MCP spec supports this natively; it just needs glue code on my end.

Get the historical dataset too

The MCP server gives your agent live access. If you want the full historical corpus as a flat CSV for offline analysis, backtests, or building your own thing on top — that's available here. 15.1M+ price records, 15,355 markets, $11.7B+ volume, one-time purchase.

The MCP server stays free either way. The dataset is the optional commercial layer for people who want bulk access without hammering an API. (For reference: polymarket-mcp-pro is currently doing ~18 weekly PyPI downloads with zero promotion budget.)

Your Polymarket Bot Is Lying To You About P&L. I Built A Free Auditor. Here's What I Found.

manja316 — Mon, 11 May 2026 10:51:01 +0000

Your Polymarket Bot Is Lying To You About P&L. I Built A Free Auditor. Here's What I Found.

If your Polymarket bot tells you it's up $34 on the week, there's a decent chance your wallet is actually down $90. The CLOB doesn't fill the way your post_order response suggests it does, and most bots never reconcile the difference.

I ran into this problem on my own crash-recovery bot, lost real money to it, and built a tool to find the gap. It's a one-line install. You give it a wallet address and it tells you how much your fill slippage is actually costing you.

pip install pnl-truthteller
pnl-truthteller --wallet 0xYourPolymarketProxy --output report.md

Read-only. No API keys. No private key. Wallet address only.

The actual gap, on my own bot

My bot logged every closed trade into SQLite with a theoretical_pnl column computed from (exit_price - entry_price) × shares. After 320 trades it claimed +$34.31. The on-chain reality:

Source	Trades	DB-reported P&L	On-chain P&L	Hidden slippage
My bot	320	$+34.31	$-90.72	$-125.03
Random wallet `0x1417…`	65	$+32.36	$-30.29	$-62.66

The second row is the part that matters. I picked a stranger's wallet off the public CLOB feed, reconstructed what their bot's DB would have said, and got the same shape: small positive reported, real negative on-chain, a multi-bps gap that nobody is watching.

That gap is the entire thesis of this tool. It's not just my bot. It's the default behavior of every bot that records P&L on order submission instead of fill confirmation.

Why it happens

Polymarket's CLOB fills in stages. FOK rejects, partial fills, sweep retries at deeper prices, dust left behind, idempotency issues on retry loops. If your code is shaped like this:

resp = client.post_order(args)
if resp["success"]:
    db.execute("INSERT INTO trades (theoretical_pnl, ...) VALUES (?, ...)", ...)

…then theoretical_pnl is computed against the intended fill price. The actual fills can be 5–25% worse, especially on sweep retries. Your DB shows the intention. The chain shows the execution. The delta is your real cost of doing business.

What the report actually looks like

# Slippage Report — 2026-04-28T14:30:00+00:00

## TL;DR
- Closed trades total: 308
- Lifetime theoretical P&L: +$33.49
- Lifetime actual P&L (on-chain fills): -$89.01
- Total slippage cost: -$122.50 (-365.8% of theoretical)
- Trades with stranded dust on-chain: 31 (47.3 shares dust)

## By exit reason
| Reason | n | Theoretical | Actual | Slippage |
|---|---|---|---|---|
| TIMEOUT | 142 | -$18.00 | -$84.50 | -$66.50 |
| TARGET | 71 | +$28.40 | +$22.10 | -$6.30 |
| RECOVERY_TRAILED | 50 | +$15.20 | +$12.40 | -$2.80 |
| STOP | 39 | +$7.89 | +$0.99 | -$6.90 |

The "by exit reason" breakdown is the most actionable column. In my case TIMEOUT exits were the entire bleed: my bot was waiting too long to flatten and the book moved against it before each forced close. Once I knew that, the fix was an hour of work. Without the report I would have kept blaming "noise."

How the matching works (the only non-obvious part)

For each closed trade the tool:

Finds the actual BUY fills by matching token_id + a timestamp window, deduplicated by orderID.
Finds the actual SELL fills that closed the position the same way.
Computes theoretical = (exit_price - entry_price) × shares (what the bot thinks).
Computes actual = sum(sell_takingAmount) - sum(buy_makingAmount) (what the chain says).
Slippage = actual - theoretical. Negative = your fill ladder walked the book down.

The dedup-by-orderID step is the one most rolled-your-own scripts miss. Sweep retries — where your bot tries 5%, 15%, 25% off the reference price — frequently log the same orderID multiple times if you call post_order from a retry loop without idempotency checks. Without dedup you double-count proceeds and your slippage looks fine when it isn't.

Three input modes, depending on how you log

1. Wallet address only (zero setup):

pnl-truthteller --wallet 0xYourProxyAddress --output report.md

Pulls every fill for the wallet from Polymarket's public CLOB API, groups by token + direction, produces the report. Works on any wallet — yours, a competitor's, a random one off the feed.

2. From your bot's SQLite (if you've been logging raw CLOB responses):

pnl-truthteller --sqlite ~/bot/trades.db \
                --positions ~/bot/positions.json \
                --output report.md

Expects a live_trades table with token_id, side, timestamp, raw_response. The raw_response should be the JSON string returned by client.post_order().

3. From JSONL (for non-Python stacks):

pnl-truthteller --trades trades.jsonl --fills fills.jsonl --output report.md

What this is not

It does not execute trades. Read-only.
It does not need your private key. Wallet address only.
It does not store your data anywhere. Local file in, local file out.
It does not promise to fix your bot. It finds the gap; you fix the bot.

Get it

PyPI: pip install pnl-truthteller — pypi.org/project/pnl-truthteller
GitHub: LuciferForge/pnl-truthteller — stars welcome, issues more welcome
The Polymarket dataset I tested it against (13,964 markets, 10.8M price records, $11.7B+ volume) is on Gumroad: manja8.gumroad.com/l/polymarket-data?utm_source=devto&utm_medium=article&utm_campaign=pnl-truthteller-week-2026-05-11

If you're running anything on the Polymarket CLOB and have not reconciled DB vs chain in the last 30 days, run this against your wallet today. The 30-second answer is worth more than the next feature you were going to add.

I Built a Free Polymarket Screener with 2,001 Market Pages — Static, Open Source, No Account

manja316 — Sun, 10 May 2026 07:28:50 +0000

I Built a Free Polymarket Screener with 2,001 Market Pages — Static, Open Source, No Account

TL;DR: I built a free Polymarket prediction-market screener with 2,001 individual market pages — top movers, highest volume, crash signals, by category. Live at luciferforge.github.io/polyscope. No login, no account, no rate-limited API calls. Built from the same 14.6M-row dataset I use for my own bot.

Updated 2026-05-25 — numbers verified from source: 13,963 markets tracked, 10.8M+ price snapshots, 43+ days of data. Community roadmap discussion →

The problem with Polymarket's UI

Polymarket has thousands of active markets. Their official UI shows a curated front page (politics + sports trending), but if you want to see:

The 50 highest-volume markets right now
The biggest probability-moves in the last 24h
Markets in a specific category (geopolitics, crypto, weather, etc.)
Markets that just crashed below their 7-day high

…you have to click into each market individually, or use their JSON API and write your own dashboard.

I wrote my own dashboard 6 months ago for personal use. Today I'm making it public.

What's at luciferforge.github.io/polyscope

A static-site screener with 2,001 individual market pages + 10 category indexes:

By category: politics, sports, crypto, geopolitics, economics, entertainment, weather, science_tech, pop_culture, other
Per market: question, current Yes/No price, 7-day price chart, total dollar volume, current liquidity, end date, resolution status
Sortable indexes: by volume, by liquidity, by 24h price change
Top movers + crash signals front page: the 50 markets with the biggest moves and the 50 closest to their 7-day low

All static HTML. No JS framework, no database call on page load. Renders in <100 ms. Indexed by Google.

Why static

Polymarket's own dashboard is rate-limited and requires JS. A static site means:

Search engines can index every individual market page
Anyone can mirror the site, fork it, run it themselves
No infrastructure cost — it's GitHub Pages
The methodology is auditable: the generator script + the SQL queries are in the repo

How it's built

The site is generated from a 10.8M-snapshot Polymarket price database I've been collecting since mid-April 2026. Every 15 minutes the collector pulls Gamma + CLOB APIs, deduplicates, and inserts into SQLite. The screener generation script reads the DB, picks the 2,000 most-active markets, and renders the static pages.

If you want to build something like this yourself, the dataset is for sale on Gumroad: 10.8M+ price snapshots, 13,963 markets, 43+ days, $9 — SQLite + CSV. Same data the screener runs on.

If you want any of those, two adjacent products:

Free CLI to audit your own Polymarket trading P&L: pnl-truthteller on PyPI. Open source.
Buyable bot template (the one I trade with): Polymarket Crash Recovery Bot — 280 trades, 80% WR. $39 on Gumroad.

Source / contributing

Everything's open source: github.com/LuciferForge/polyscope. Discussions are open — what screener views would you actually use? Vote on the roadmap →. Pull requests welcome.

The screener regenerates from a daily DB snapshot. Found a market that should be on the trending page but isn't? Open an issue with the market_id.

Built by @manja316. I run a Polymarket trading desk + a prediction market dataset business. Free tools for the same audience that buys the data.

Forem: manja316

Building a free Polymarket screener: how I turned 13,963 markets into a single scannable page

The data layer

Ranking: movers vs volume

Why static + GitHub Pages

What I'd build next (and won't, alone)

Try it

Every Indian GST invoice generator forces signup. I built one that doesn't.

What a GST invoice needs (the bureaucratic part)

How the PDF gets generated (no server)

What I deliberately didn't build

What I learned about Indian tax software

What's next

I rebuilt crontab.guru with three features I needed every week

1. Plain English → cron (the reverse direction)

2. Next 10 actual run times

3. Systemd timer equivalent

What this is built on

Edge cases I haven't handled

I built an airdrop scanner that tells crypto farmers how much they've already lost. Most see a number they don't like.

The reality check most tools don't show you

1. Pairwise Sybil clustering detection

2. Pattern-aware scoring, not volume-only

3. Gas cost reality, in USD, headlined

The tech stack

What's curated for May 2026

Honest about monetization

What I'd love feedback on

Claude Code Skills Pack — 15 Production Skills, 5 Hooks, 7 Slash Commands ($99 lifetime)

What's in the pack

A sample skill in full

Why it costs money

Install in 5 minutes

License

Refund

Free Polymarket Dataset on Kaggle: 13,963 Active Markets + 100K Price Sample (May 2026)

What's in it

What you can build in 20 minutes

What it's NOT

How it was collected

Why a Kaggle release at all

Limitations to know

License

What I'd love feedback on

The anatomy of a single-purpose AI tool (and why I shipped two of them this week)

The shape

Why this shape wins

Architecture (small enough to fit in a tweet)

The prompt that does the heavy lifting

What I'd build next in this shape

Try them

Every Indian GST invoice generator forces signup. I built one that doesn't.

What a GST invoice needs (the bureaucratic part)

How the PDF gets generated (no server)

What I deliberately didn't build

What I learned about Indian tax software

What's next

Week 1 of pnl-truthteller: 22 pypi downloads, 0 stars, and one real bug report

The numbers (week 1)

What I'm calling success vs. noise

What I'd do differently if shipping week-1 again

What's in the dataset (if you actually want it)

Code, and the only ask

Give Claude (or Cursor) live Polymarket prediction-market data with one MCP server

Give Claude (or Cursor) live Polymarket prediction-market data with one MCP server

The numbers behind it

Install in 30 seconds

Wire it into Claude Desktop

The seven tools

What I actually use it for

Why this isn't just a thin wrapper

What's coming in v0.2

Get the historical dataset too

Links

Your Polymarket Bot Is Lying To You About P&L. I Built A Free Auditor. Here's What I Found.

Your Polymarket Bot Is Lying To You About P&L. I Built A Free Auditor. Here's What I Found.

The actual gap, on my own bot

Why it happens

What the report actually looks like

How the matching works (the only non-obvious part)