TokenShark: Localized cost monitoring for LLM calls

A developer on Reddit mentioned losing their house and marriage over a token cost miscalculation, which sounds like an extreme outlier, but when you're running unoptimized loops against the OpenAI or Anthropic APIs, that kind of financial drift is a very real risk. Everyone points toward the heavy hitters like LangSmith, Helicone, or Langfuse, but those are fundamentally dashboard-first architectures. They force you into an observability paradigm where you're managing accounts, wrapping SDKs, or spinning up Docker containers just to see what your spend looks like. They are built for the enterprise monitoring layer, not the developer who just wants to know their local burn rate without routing traffic through a third-party proxy or a centralized service. I've been working on TokenShark to address this specific gap because I wanted something that stays local and doesn't require a heavy footprint. The core implementation is actually quite delicate; I had to move from basic module-level patching to a more robust class-level patching approach to ensure the interceptor actually catches calls made via specific client instances rather than failing to hook the module entirely. I also had to prioritize async support from the ground up because if you're building anything production-ready, you aren't running purely synchronous code. One of the biggest technical headaches has been the logic for Anthropic's cache pricing. Most of the existing observability tools are actually quite unreliable here—they tend to miscalculate cached tokens and report them at full price, which gives you a completely false sense of your actual costs. TokenShark handles that math correctly so the telemetry is actually useful for budgeting. It’s intended to be a lightweight interceptor that logs cost, latency, and token usage directly to your terminal. I'm aiming to get this onto PyPI within the week.

https://pypi.org/project/tokenshark/
https://promptcube3.com