Stop Wasting Money on AI APIs You Can't Track: OpenCode Bar Exposed

You're bleeding money and you don't even know it.

Every single day, developers like you are racking up hundreds of dollars in AI API costs across multiple providers—OpenRouter, Claude, GitHub Copilot, Gemini, Codex—and have absolutely zero visibility into where it's all going. You check your credit card statement at month-end and feel that sickening lurch in your stomach. Another $400? For what?

The dirty secret of modern AI development is that token usage is intentionally opaque. Providers want you confused. They want you to keep feeding the meter without asking questions. Meanwhile, you're switching between browser tabs, logging into five different dashboards, trying to piece together your burn rate like some digital forensic accountant.

What if I told you there's a tool that eliminates this chaos in under 60 seconds? No spreadsheets. No manual API calls. No more surprise bills.

Meet OpenCode Bar—the effortless token usage tracker that lives in your macOS menu bar and automatically monitors every AI provider you use. Built by the engineering team at OP.GG (yes, that OP.GG), this open-source tool is what top developers are quietly installing to reclaim control over their AI spending.

Ready to stop flying blind? Let's dive deep.

What is OpenCode Bar?

OpenCode Bar is a native macOS menu bar application that automatically detects and monitors all AI providers registered in your OpenCode configuration. Think of it as your personal AI spending command center—always visible, always updating, completely effortless.

Created by Sangrak Choi and the team at OP.GG—the gaming analytics giant that processes billions of data points daily—this tool brings enterprise-grade monitoring to individual developers. The pedigree matters: when a company that built its reputation on real-time data visualization turns its attention to AI cost tracking, you pay attention.

Why it's trending now:

The explosion of AI coding assistants in 2024-2025 created a perfect storm. Developers aren't using one AI anymore—they're stacking multiple providers for different tasks. Claude for architecture, Copilot for autocomplete, OpenRouter for model flexibility, Gemini for context windows. Each with different pricing models, quotas, and billing cycles. The cognitive overhead became unbearable, and the community started desperate searching for solutions.

OpenCode Bar arrived at exactly the right moment. With 15+ supported providers, zero-configuration setup, and a clean native macOS interface, it spread through developer Twitter and Hacker News like wildfire. The GitHub repository has become a must-star for anyone serious about AI cost management.

The killer insight? It doesn't just track—it predicts. End-of-month estimates using weighted averages mean you know your final bill before it hits.

Key Features That Make It Irresistible

Automatic Provider Detection (Zero Configuration)

This is where OpenCode Bar absolutely destroys the competition. No API keys to paste. No config files to edit. The app reads your existing OpenCode auth.json automatically, with intelligent multi-path support:

• $XDG_DATA_HOME/opencode
• ~/.local/share/opencode
• ~/Library/Application Support/opencode (macOS fallback)

Dynamic updates mean new providers appear instantly as you add them. Smart categorization separates pay-as-you-go from quota-based providers—critical for understanding your risk exposure.

Multi-Source Account Discovery (The Secret Weapon)

Here's where OP.GG's engineering DNA shines. For providers like GitHub Copilot, OpenCode Bar doesn't just check one place—it hunts across your entire system:

Multiple accounts from different sources? Automatically deduplicated and merged by stable account metadata. This is the kind of intelligent engineering that separates toys from tools.

Real-Time Menu Bar Dashboard

• Color-coded progress indicators: Green → Yellow → Orange → Red. At a glance, you know what's urgent.
• Detailed submenus: Click any provider for in-depth metrics, model breakdowns, and auth source labels.
• Gemini account labels: Shows Gemini CLI (email) when available, with graceful fallback to Gemini CLI #N.

Usage History & Predictions

• Daily tracking: Request counts and overage costs with precision.
• EOM prediction: Weighted average estimates so you're never surprised.
• Add-on cost tracking: See exactly when you exceed limits and what it costs.

Subscription Management

Configure your subscription tier for each quota-based provider. Accurate monthly cost calculation based on your actual plan—not generic estimates. Orphaned plan cleanup automatically detects and resets stale entries.

Developer Experience Polish

• Launch at login: Start automatically with macOS.
• Parallel fetching: All providers update simultaneously via TaskGroup—no sequential waiting.
• Auto updates: Seamless background updates via Sparkle framework.
• Smart caching: Falls back to cached data on network errors.
• Graceful degradation: Shows available providers even if some APIs fail.

4 Concrete Use Cases Where OpenCode Bar Shines

1. The Multi-Provider Freelancer

You're a freelance developer using Claude for client architecture reviews, GitHub Copilot for daily coding, and OpenRouter for experimental models. Previously, you spent 20 minutes every morning checking five dashboards. With OpenCode Bar: One click in your menu bar, instant visibility across all providers. You catch Copilot hitting 77% quota before a critical deadline and switch to Codex seamlessly.

2. The Startup Engineering Lead

Your team of 12 developers each has multiple AI accounts. Month-end reconciliation was a nightmare—expense reports, shared credit cards, mystery charges. You deploy OpenCode Bar across the team, use the JSON CLI output to build a centralized monitoring dashboard, and finally have predictable AI infrastructure costs. The EOM prediction alone saves you hours of spreadsheet torture.

3. The AI Power User Hitting Quota Walls

You push limits. Gemini CLI for massive context windows, Kimi K2.5 for specific coding tasks, MiniMax for rapid prototyping. But you keep hitting invisible walls mid-flow. OpenCode Bar's real-time quota monitoring with reset time tracking means you know exactly when your limits refresh. No more interrupted deep-work sessions because you burned through your Anthropic quota at 2 PM.

4. The CI/CD Pipeline Architect

You're running automated code review pipelines that call multiple AI providers. Before expensive operations, your scripts call opencodebar status --json, parse the output, and route requests to providers with available quota. Failed builds due to rate limits? Eliminated. Intelligent provider selection based on real-time availability? Automated.

Step-by-Step Installation & Setup Guide

Option 1: Homebrew (Recommended)

The fastest path to AI cost sanity:

# Install via Homebrew Cask
brew install --cask opgginc/tap/opencode-bar

That's it. The app will appear in your Applications folder.

Option 2: Manual Download

1. Visit the Releases page on GitHub.
2. Download the latest .dmg file.
3. Drag OpenCode Bar.app to your Applications folder.
4. Launch and grant necessary permissions.

Prerequisites

Before launching, ensure you have:

• macOS 13.0+ (Ventura or later)
• OpenCode installed with authenticated providers
• At least one AI provider configured in your OpenCode setup

First Launch Configuration

1. Launch the app: OpenCode Bar appears in your menu bar as an icon.
2. Verify detection: Click the icon—you should see your providers populate automatically.
3. Configure subscriptions (optional): For quota-based providers, click Settings → Subscriptions to set your plan tier for accurate cost calculation.
4. Enable launch at login: Settings → General → Start at Login.
5. Install CLI (optional but powerful): Click "Install CLI" from the Settings menu for programmatic access.

Build from Source (Developers)

Want to hack on it? Here's the complete build process:

# Clone the repository from GitHub
git clone https://github.com/opgginc/opencode-bar.git
cd opencode-bar

# Build the Xcode project
xcodebuild -project CopilotMonitor/CopilotMonitor.xcodeproj \
  -scheme CopilotMonitor -configuration Debug build

# Open the built app (auto-detects build path)
open "$(xcodebuild -project CopilotMonitor/CopilotMonitor.xcodeproj \
  -scheme CopilotMonitor -configuration Debug \
  -showBuildSettings 2>/dev/null | \
  sed -n 's/^[[:space:]]*BUILT_PRODUCTS_DIR = //p' | head -n 1)/OpenCode Bar.app"

Build requirements:

• macOS 13.0+
• Xcode 15.0+
• Swift 5.9

Development Setup with Git Hooks

Contributing? Maintain code quality effortlessly:

# Configure pre-commit hooks (run once after clone)
make setup

This installs:

• SwiftLint: Automatic Swift style checking on staged files
• action-validator: GitHub Actions workflow validation

Manual checks: make lint or make lint-swift / make lint-actions.

REAL Code Examples from the Repository

Let's examine actual functionality from OpenCode Bar's CLI and internals.

Example 1: Basic Status Check

The bread-and-butter command every developer needs:

# Display all providers with usage in formatted table
opencodebar status

Sample output you'll see:

Provider              Type             Usage       Key Metrics
─────────────────────────────────────────────────────────────────────────────────
Claude                Quota-based      77%         23/100 remaining
Codex                 Quota-based      0%          100/100 remaining
Copilot (user1)       Quota-based      45%         550/1000 remaining
Copilot (user2)       Quota-based      12%         880/1000 remaining
Gemini CLI (user1@gmail.com) Quota-based      0%          100% remaining
Gemini CLI (user2@company.com) Quota-based    15%         85% remaining
Kimi for Coding       Quota-based      26%         74/100 remaining
MiniMax Coding Plan   Quota-based      0%,0%      100/100 remaining
OpenCode Zen          Pay-as-you-go    -           $12.50 spent
OpenRouter            Pay-as-you-go    -           $37.42 spent

Why this matters: The table format is designed for rapid cognitive parsing. Color coding in the actual app (green/yellow/orange/red) gives instant visual priority. Notice how multi-account providers like Copilot and Gemini show individual account breakdowns—critical for team environments where personal and work accounts overlap.

Example 2: JSON Output for Automation

When you need to program against your usage data:

# Get structured JSON for scripting and automation
opencodebar status --json

Actual JSON structure returned:

{
  "claude": {
    "type": "quota-based",
    "remaining": 23,
    "entitlement": 100,
    "usagePercentage": 77,
    "overagePermitted": false
  },
  "copilot": {
    "type": "quota-based",
    "remaining": 1430,
    "entitlement": 2000,
    "usagePercentage": 28,
    "overagePermitted": true,
    "accounts": [
      {
        "index": 0,
        "login": "user1",
        "authSource": "opencode",
        "remaining": 550,
        "entitlement": 1000,
        "usagePercentage": 45,
        "overagePermitted": true
      },
      {
        "index": 1,
        "login": "user2",
        "authSource": "copilot_cli_keychain",
        "remaining": 880,
        "entitlement": 1000,
        "usagePercentage": 12,
        "overagePermitted": true
      }
    ]
  },
  "gemini_cli": {
    "type": "quota-based",
    "remaining": 85,
    "entitlement": 100,
    "usagePercentage": 15,
    "overagePermitted": false,
    "accounts": [
      {
        "index": 0,
        "email": "user1@gmail.com",
        "accountId": "100663739661147150906",
        "remainingPercentage": 100,
        "modelBreakdown": {
          "gemini-2.5-pro": 100,
          "gemini-2.5-flash": 100
        }
      },
      {
        "index": 1,
        "email": "user2@company.com",
        "accountId": "109876543210987654321",
        "remainingPercentage": 85,
        "modelBreakdown": {
          "gemini-2.5-pro": 85,
          "gemini-2.5-flash": 90
        }
      }
    ]
  },
  "openrouter": {
    "type": "pay-as-you-go",
    "cost": 37.42
  }
}

Technical insight: The schema distinguishes quota-based vs pay-as-you-go types fundamentally differently. Quota providers expose remaining/entitlement/usagePercentage, while pay-as-you-go exposes cost. The overagePermitted boolean is crucial for risk assessment—knowing whether you'll get cut off or charged more.

Practical implementation: Pipe this to jq for filtering, or ingest into monitoring systems like Datadog/Prometheus.

Example 3: Provider-Specific Deep Dives

When you need granular detail about one service:

# Detailed info for specific providers
opencodebar provider claude
opencodebar provider gemini_cli
opencodebar provider minimax_coding_plan

# JSON variant for programmatic access
opencodebar provider claude --json
opencodebar provider minimax_coding_plan --json

MiniMax-specific handling (shows the engineering depth):

# MiniMax has unique API behavior - fields named 'usage' actually contain 'remaining'
opencodebar provider minimax_coding_plan

The app handles MiniMax's quirk where current_interval_usage_count and current_weekly_usage_count behave as remaining counts despite their names. OpenCode Bar correctly calculates: used_percent = total - remaining. Without this fix, you'd see completely inverted percentages.

Example 4: CLI Installation Script

For team deployment or dotfiles automation:

# Manual CLI installation (alternative to menu bar "Install CLI" button)
bash scripts/install-cli.sh

# Verify successful installation
opencodebar --help

Exit codes for reliable scripting:

Advanced Usage & Best Practices

Menu Bar Optimization

Configure your status bar for maximum information density:

• Menu Bar Display: Choose Total Cost for spending awareness, Icon Only for minimalism, or Only Show for specific provider focus.
• Critical Badge: Enable to get visual alerts when usage crosses thresholds.
• Provider Icon: Append provider-specific icons next to the main icon for instant recognition.

Pro tip: The Status Bar Percent uses a fixed priority: Weekly → Monthly → Daily → Hourly → aggregate fallback. If multiple values exist at the same priority, the highest (most critical) is shown. This conservative approach ensures you never underestimate usage.

Automation Patterns

Build intelligent workflows with the CLI:

# Pre-flight check before expensive CI jobs
if [ $(opencodebar provider claude --json | jq '.usagePercentage') -gt 80 ]; then
  echo "WARNING: Claude quota at 80%, switching to Codex fallback"
  export AI_PROVIDER=codex
fi

Multi-Account Hygiene

GitHub Copilot's multi-source discovery can surface accounts you forgot about. Periodically audit with opencodebar provider copilot --json and remove stale Keychain entries or browser cookies for accounts you no longer use.

Subscription Settings Discipline

For quota-based providers, always configure your actual plan tier. Without this, cost predictions are inaccurate. The app detects orphaned plans automatically—if you downgrade or cancel, stale entries reset to prevent phantom cost calculations.

Comparison with Alternatives

The verdict: OpenCode Bar occupies a unique position—native macOS integration with open-source flexibility and enterprise-grade multi-provider intelligence. Cloud cost tools miss local AI tools. Custom scripts rot without maintenance. Manual checking doesn't scale. This is the only solution that just works across your entire AI stack.

FAQ

Q: Does OpenCode Bar work without OpenCode installed?

Partially. Some providers like GitHub Copilot are detected through alternative sources (Keychain, VS Code config, browser cookies). However, full auto-detection requires OpenCode with authenticated providers. Standalone tools like codex-lb are also supported.

Q: Is my data sent to any third-party servers?

Absolutely not. All data stays local. Direct API communication with providers only. The app uses your existing tokens with read-only access—no additional permissions, no external data collection.

Q: Why does my auth.json show different paths than expected?

OpenCode Bar searches multiple standard locations: $XDG_DATA_HOME/opencode, ~/.local/share/opencode, and ~/Library/Application Support/opencode. Set XDG_DATA_HOME explicitly if you use custom paths.

Q: Can I use this for team/billing reporting?

Yes! The --json output is designed for ingestion into reporting systems. Combine with jq for filtering, or build dashboards that aggregate multiple developers' outputs. Note: each developer runs their own local instance—there's no central server.

Q: What happens when a provider API fails?

Graceful degradation kicks in. Failed providers show cached data with visual indicators. Other providers continue updating normally. The app never blocks on a single slow or failing API thanks to Swift's TaskGroup parallel fetching.

Q: How accurate are the EOM predictions?

Predictions use weighted averages based on your actual usage patterns. They're estimates, not guarantees—especially for spiky workloads. Use them for budgeting, not precise financial forecasting.

Q: Will this work on Windows or Linux?

Currently macOS 13+ only. The Swift-native codebase and Keychain integration are deeply macOS-specific. Windows/Linux ports would require substantial rewrites. Vote with a 👍 on the relevant GitHub issue if you need cross-platform support.

Conclusion

Here's the uncomfortable truth: every day you spend without AI usage visibility is a day you're potentially burning money you can't afford.

OpenCode Bar transforms this chaos into clarity. Sixty seconds of installation. Zero ongoing configuration. Instant visibility across 15+ providers from a single menu bar icon. The CLI unlocks automation possibilities that custom scripts would take weeks to replicate.

The engineering pedigree from OP.GG shows in every detail—the intelligent multi-source account discovery, the conservative priority-based percentage calculations, the graceful handling of quirky APIs like MiniMax. This isn't a weekend hack project; it's a production-quality tool built by people who understand data at scale.

My recommendation? Install it today. Not tomorrow, not after your next surprise bill. Today. The Homebrew one-liner takes less time than reading this conclusion.

brew install --cask opgginc/tap/opencode-bar

Then star the GitHub repository, watch for releases, and join the growing community of developers who refuse to fly blind with their AI spending.

Your future self—reviewing a predictable, understood AI infrastructure bill—will thank you.

Made with tiredness for AI power users. Built with precision by OP.GG and Sangrak Choi.