DEV Community: Sovyte

🦈 I'm 13 and I built TokenShark: Real-Time Python LLM Cost Tracking with 1 Line of Code.

Sovyte — Tue, 14 Jul 2026 18:53:19 +0000

🚀 Join the Community: We are building in public! Drop into our Discord Server to grab early alpha builds, report bugs, and chat directly with me about the roadmap!

Hey Dev Community! 👋

I’m a 13-year-old developer, and I just built TokenShark. It is a lightweight Python tool designed to show you your real-time LLM token usage and financial costs right inside your terminal.

When building AI apps, token costs can spiral out of control fast. I wanted a solution that was instant, local, and required zero configuration.

Here is how TokenShark works, why I chose a controversial architecture pattern to build it, and how you can help me test it.

⚡ What is TokenShark?

TokenShark patches your Python LLM client with one single import. It gives you instant visibility into your AI spend without forcing you to sign up for another SaaS dashboard.

🔥 Key Features

Zero Configuration: Just add import tokenshark to your code.
Real-Time Terminal Output: See cost breakdowns as streaming responses land.
Accurate Pricing: Deep integration that accounts for prompt caching discounts.
100% Private: No accounts required. No traffic leaves your machine.
Metadata Tagging: Filter and tag your cost metrics per-request.

🛠️ The Architecture Choice: Why Monkey Patching?

When deciding how to hook into the AI SDKs (like OpenAI or Anthropic), I evaluated three methods. Here is why I skipped proxies and wrappers:

Method	Friction	Privacy	Why I Chose/Skipped It
SDK Wrapping	🔴 High	🟢 Safe	Requires rewriting your code everywhere an API is called. Too much friction.
Proxy (e.g. Helicone)	🟡 Medium	🔴 Risky	Requires changing base URLs. Routes your data through external servers.
Monkey Patching	🟢 Zero	🟢 Safe	Modifies provider objects at runtime locally. Just `pip install` and you are done.

⚠️ A Note on Transparency: Monkey patching means modifying third-party objects at runtime. While perfectly safe when done right, I believe in absolute transparency. For the final release, I will document exactly which internal classes and methods TokenShark modifies so you always know what is running under the hood.

📅 Roadmap: What's Next?

The official launch is happening on July 17th (though early access versions will drop sooner!).

Here is what I am building next:

Slack Integration: Get instant budget alerts pushed to your team channels.
Web Dashboard: A local, beautiful UI to visualize your historic spend trends.
Mobile App: Monitor your production API burn rates from your phone.

🦈 I Need Your Constructive Criticism!

Because I am 13, I don't have a massive team testing this—it's just me. TokenShark is in its early phases, which means there will be bugs.

I want to build what the community actually needs. Please break my tool, test its limits, and give me your most brutal constructive feedback so I can improve it.

Let's Connect!

💬 Discord: Join the TokenShark Server
📧 Email: tokenshark@tuta.io
𝕏/Twitter: tokenshark_dev

If you find this project interesting, let me know in the comments below! What features should I add next?

[Boost]

Sovyte — Thu, 09 Jul 2026 10:44:34 +0000

Privacy-first local logging with no account

Sovyte

Jul 9

I'm 13, Building a CLI Tool for LLM Cost Tracking, and Shipping It in 10 Days

#showdev #cli #llm #python

3 min read

[Boost]

Sovyte — Thu, 09 Jul 2026 09:52:43 +0000

Privacy-first local logging with no account

Sovyte

Jul 9

I'm 13, Building a CLI Tool for LLM Cost Tracking, and Shipping It in 10 Days

#showdev #cli #llm #python

3 min read

I'm 13, Building a CLI Tool for LLM Cost Tracking, and Shipping It in 10 Days

Sovyte — Thu, 09 Jul 2026 09:52:09 +0000

The problem

A few weeks ago I read a Reddit comment that stuck with me:

"I lost my house — and, subsequently, my marriage — due to a token cost miscalculation."

42 upvotes. Not because it's rare — because everyone who's shipped an LLM feature has their own smaller version of that fear. You add an OpenAI call to your app, ship it, and then you're checking your billing dashboard every few hours hoping nothing spiked while you weren't looking.

I went looking for a tool that just... shows you the cost. In real time. In your terminal. Without an account, without a dashboard, without fifteen minutes of setup.

It didn't exist. So I'm building it.

What TokenShark does

import tokenshark
tokenshark.monitor()

That's the entire integration. One import. Your existing OpenAI or Anthropic calls now log their cost, latency, and token usage locally — no data leaves your machine, no account required.

tokenshark dashboard

Shows you a live terminal view of every call, sorted by cost, with a running total for the day.

# tokenshark.yaml
daily_budget: 5.00
slack_webhook: "your-webhook-here"

Set a budget. Get a Slack alert before you blow through it. Optionally raise a hard stop.

Why I'm building this specifically

I did a lot of research before writing any code — competitive analysis across Helicone, LangSmith, Langfuse, Opik, Promptfoo. Here's what I found:

Every single one of them is dashboard-first, not terminal-first. Setting up Helicone means routing your traffic through their proxy. LangSmith needs an account, an API key, environment variables, SDK wrapping. Langfuse self-hosted needs Docker and S3 configuration. None of them are "one import and you're done."

LangSmith has a confirmed pricing bug. They show cached tokens at full price when Anthropic actually charges 10% of the normal rate for cache reads. Multiple developers have hit this. TokenShark calculates cache pricing correctly — cache creation at 25% of base input, cache reads at 10% — verified against official docs.

Nobody does per-request attribution well. The most repeated complaint I found in research across Reddit and GitHub issues: developers can see total cost, but can't tell which specific request, feature, or user caused a spike. TokenShark supports optional metadata tagging so you can break costs down by whatever matters to you.
*Building from Oman.

The build

I'm running this as a public 10-day sprint. Architecture decided in advance, one clear goal per day, shipping to PyPI by day 7, launching on Show HN by day 9.

Some of the interesting technical decisions so far:

Class-level patching, not module-level. My first architecture draft patched openai.chat.completions.create directly. Turns out that only catches one calling pattern — most real code does client = OpenAI(); client.chat.completions.create(), which the module-level patch silently misses. Caught this before writing the actual interceptor by testing against a fake SDK I built specifically to verify behavior offline.
Sync and async support from day one. Wasn't in my original spec, but async is common enough in production LLM code that skipping it would have made the tool feel incomplete on launch.
Never logging prompt content. Only metadata — token counts, cost, latency, optional tags you provide. This is a deliberate privacy decision, not a limitation. TokenShark should never be a compliance risk for anyone using it.

What's next

Days 3-6 are cost verification, the dashboard, Slack alerts, and metadata tagging. Day 7 is PyPI. Day 9 is Show HN.

I'll be posting here and on Twitter as it progresses — the wins and the bugs both. If you've hit the "surprise LLM bill" problem yourself, I'd genuinely like to hear about it. It's exactly the kind of thing that's shaping what TokenShark becomes before v0.1 even ships.

Follow along: [https://github.com/Sovyte/TokenShark-v.01]

[Boost]

Sovyte — Wed, 08 Jul 2026 15:47:18 +0000

Sovyte

Jul 8

Me, a 13 yr old dev built an LLM cost tracker called TokenShark on my laptop at Hyderabad airport

#ai #programming #python #claude

4 min read

Me, a 13 yr old dev built an LLM cost tracker called TokenShark on my laptop at Hyderabad airport

Sovyte — Wed, 08 Jul 2026 15:46:59 +0000

I built an LLM cost tracker on my laptop at Hyderabad airport

We had a layover in Hyderabad. Long one. Like six hours. I had my laptop and an idea I'd been sitting on.

The problem

I build stuff with LLMs. Chatbots, summarizers, agents that check if my homework makes sense. But you never know what it costs until the bill comes. You call GPT-4o, it works, you call it again, it works again, you ship it, and then your dad asks about the credit card.

I wanted cost to show up in real-time. In the terminal. Without changing my code. Two lines:

import tokenshark
tokenshark.monitor()

Every OpenAI or Anthropic call gets intercepted, cost-calculated, and logged. Like this:

[TokenShark] OpenAI gpt-4o | 1,247â†‘ 382â†“ | $0.0604 | 340ms | trace_id: req_7a3f
[TokenShark] Anthropic claude-3-5-sonnet | 890â†‘ 1,204â†“ | $0.0891 | 1.2s | user: alice

I called it TokenShark because sharks are cool and tokens cost money.

The catch

Hyderabad airport WiFi is that kind that "connects" but doesn't actually work. I couldn't pip install anything. No packages, no testing against real SDKs. I had an architecture doc I wrote weeks ago 459 lines of exactly how this should work. And I had weird knowledge of the OpenAI Python SDK.

So I typed. For hours.

What I built

Eight files, ~1,350 lines.

proxy.py patches the actual OpenAI and Anthropic clie
nt classes â€” not module-level shortcuts, the real classes. I remembered from reading the SDK source that their client is instance-based. You do client = OpenAI() and then client.chat.completions.create(...). So patching openai.chat.completions.create only catches module-level calls. Real code uses instances. I had to patch openai.resources.chat.completions.Completions.create and anthropic.resources.messages.Messages.create.

Streaming was the worst part. OpenAI streams don't include usage by default. You need stream_options={"include_usage": True} or every chunk has usage=None. TokenShark auto-injects that. But if some proxy strips it out anyway, it falls back to tiktoken estimation and marks the row as estimated in the database.

Anthropic streams differently â€” usage is split across message_start and message_delta events. I had to assemble the full picture from partial data.

Cached tokens: OpenAI nests them at usage.prompt_tokens_details.cached_tokens, but some older responses have a flat usage.cached_tokens. I check both. Anthropic has cache_creation_input_tokens and cache_read_input_tokens as flat attributes. Got all this from memory and a few web searches that squeezed through the spotty airport WiFi.

tracker.py has the cost calculation, SQLite schema, and database writes. Every call gets logged with provider, model, token counts, cost in dollars, latency, custom tags, whether the cost was estimated or exact, and error messages if it failed.

config.py loads tokenshark.yaml, merges with defaults, checks for accidentally-committed API keys at every nesting level (not just top-level), and resolves Slack webhooks from env vars. I caught a real bug here â€” my first draft used dict(_DEFAULT_CONFIG) which is a shallow copy, so mutating nested sections corrupted the module-level default. Fixed with copy.deepcopy(). Felt pretty smart about that one.

exceptions.py, __init__.py, pyproject.toml â€” standard stuff. I made openai and anthropic optional extras so you don't have to install both if you only use one.

Testing with fake SDKs

Couldn't test against real packages. No internet, no pip. So I built fake OpenAI and Anthropic SDKs. Faithful replicas of the real class structures with realistic streaming behavior.

My fake OpenAI sends chunks where only the final one has usage data (and only if stream_options was set). My fake Anthropic sends message_start and message_delta events with split usage. Tested sync and async clients, streaming and non-streaming, errors, Ollama routing, double monitor() calls, config merging, dangerous key detection â€” everything.

Hand-verified the cost math. Fake Claude call with 200 cache-read tokens, 80 cache-creation tokens, 30 output tokens at placeholder rates: (200*3 + 80*15)/1e6 + 30*0.75/1e6 = $0.0018225. Matched exactly what my code logged to SQLite.

I was sitting in a plastic airport chair at 2 AM running SQLite queries on my laptop. This is my life.

What's left

About 60% through Day 2. Still need: CLI tool, web dashboard, Slack alerts, real tests against actual SDKs, verified pricing (some are placeholders right now), more providers.

Why I'm sharing this

Not trying to be a prodigy. Just a kid who likes building things and got stuck at an airport with an idea and too much energy.

But LLM costs are invisible until they hurt. Making them visible in real-time with zero friction feels like something every developer should have.

If you've ever been surprised by an LLM bill, maybe give it a look. Or star it. Or tell me why my architecture is wrong. All good outcomes.

pip install tokenshark[openai,anthropic]  # soon

Or hack on it:

git clone https://github.com/your-org/tokenshark.git
cd tokenshark
pip install -e ".[openai,anthropic]"

May your tokens be few and your insights be many.