New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Usage Based Billing

by hashgraph-online in hashgraph-online/awesome-codex-plugins

Dodo Payments usage-based billing that charges per measured unit, covering meters, usage event ingestion by eventname, aggregation, free thresholds, priceperunit, and metered subscriptions.

Apache-2.0Auto-check passedBackend & APIs

Install Usage Based Billing

skills CLI
$ npx skills add hashgraph-online/awesome-codex-plugins --skill usage-based-billing -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install hashgraph-online/awesome-codex-plugins usage-based-billing --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/hashgraph-online/awesome-codex-plugins.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/dodopayments/dodo-agent-plugin/skills/usage-based-billing .claude/skills/usage-based-billing && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
usage-based-billing
GitHub stars
1.3k
Token cost
~3.5k tokens
SKILL.md length
967 words
Files
2 (incl. references)
Skills in repo
714
Repo updated
First seen
Licence
Apache-2.0

At a glance

Dodo Payments usage-based billing that charges per measured unit, covering meters, usage event ingestion by eventname, aggregation, free thresholds, priceperunit, and metered subscriptions.

  • Works in 5 steps: Using Unstable or Reused Event IDs → Using Fire-and-Forget Ingestion → Clock Skew in Timestamps → …
  • Billing per API call
  • SKILL.md covers When to use this skill, Core Concepts, Meter Lifecycle and Event Ingestion, plus 6 more sections
  • Reaches test.dodopayments.com; needs DODO_PAYMENTS_API_KEY

What it does

Usage Based Billing is an agent skill from hashgraph-online/awesome-codex-plugins. Dodo Payments usage-based billing that charges per measured unit, covering meters, usage event ingestion by eventname, aggregation, free thresholds, priceperunit, and metered subscriptions. Use when billing per API call, AI token, storage, or bandwidth, sending usage events, or adding metered pricing to a plan; use credit-based-billing for prepaid credit pools.

Its SKILL.md is about 3.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/instrumentation.md`).

It sits in Backend & APIs, covering Payments and billing. The repository describes itself as: A curated list of awesome OpenAI Codex / ChatGPT plugins, skills, and resources. The 1 Codex Marketplace. See live plugins at: https://hol.org/plugins/best-codex-plugins. The licence is Apache-2.0.

When your agent uses it

  • Billing per API call
  • Sending usage events
  • Adding metered pricing to a plan
  • Use credit-based-billing for prepaid credit pools

Example prompts

  • “/usage-based-billing”

Requirements

  • A credential in DODO_PAYMENTS_API_KEY

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Using Unstable or Reused Event IDs
  2. Using Fire-and-Forget Ingestion
  3. Clock Skew in Timestamps
  4. Ingesting on the Client Side
  5. Mismatched Event Names

What it can do on your machine

Read from SKILL.md and the folder at commit 9e7b281. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are typescript and json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • test.dodopayments.com

    Also links to:

    • docs.dodopayments.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • DODO_PAYMENTS_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Usage Based Billing loads about 3.5k tokens when it runs, and up to ~4.3k if it reads all its reference files. Until then it costs about 97 tokens; SKILL.md has 967 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~97
When it runs · the whole SKILL.md, loaded when a task matches
~3.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from hashgraph-online/awesome-codex-plugins at commit 9e7b281, republished under its Apache-2.0 licence (© hashgraph-online). 967 words, ~3,514 tokens.

Download SKILL.mdSave it as .claude/skills/usage-based-billing/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
usage-based-billing
description
Dodo Payments usage-based billing that charges per measured unit, covering meters, usage event ingestion by event_name, aggregation, free thresholds, price_per_unit, and metered subscriptions. Use when billing per API call, AI token, storage, or bandwidth, sending usage events, or adding metered pricing to a plan; use credit-based-billing for prepaid credit pools.

Dodo Payments Usage-Based Billing

Reference: docs.dodopayments.com/features/usage-based-billing

Charge customers for what they actually use—API calls, storage, AI tokens, or any metric you define.

When to use this skill

  • You need to bill customers based on consumption (API calls, tokens, storage, bandwidth).
  • You want to combine usage charges with subscriptions or one-time purchases.
  • You need to track and aggregate events into billable quantities.
  • You're building an AI service, SaaS platform, or infrastructure product with metered features.

Core Concepts

Events

Usage records sent from your application to Dodo. Each event is attributed to a customer and matched to a meter by its event_name.

json
{
  "event_id": "evt_unique_123",
  "customer_id": "cus_abc123",
  "event_name": "api.call",
  "timestamp": "2025-01-21T10:30:00Z",
  "metadata": { "endpoint": "/v1/users", "tokens": 150 }
}
Meters

Filters and aggregates events into billable quantities. A meter specifies:

  • Event name: which events to match (case-sensitive)
  • Aggregation type: how to combine events (count, sum, max, last)
  • Measurement unit: the billing unit (calls, tokens, GB, etc.)
  • Optional filters: conditions events must meet to be counted
Aggregation Types
TypeUse CaseExample
CountTotal eventsAPI calls, image generations
SumAdd values from a propertyTokens used, bytes transferred
MaxHighest value in a periodPeak concurrent users
LastMost recent valueCurrent storage used

For sum, max, and last, you specify which metadata property to aggregate.

Pricing

Attach a meter to a product price to charge per unit:

  • Price per unit: e.g., $0.001 per API call
  • Free threshold: e.g., 1,000 free calls per month
  • Charge formula: (usage − threshold) × price_per_unit

Example: 2,500 calls − 1,000 free = 1,500 × $0.02 = $30.00

Meter Lifecycle

Create a Meter
typescript
import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'test_mode',
});

const meter = await client.meters.create({
  name: 'API Requests',
  event_name: 'api.call',
  aggregation: { type: 'count' },
  measurement_unit: 'calls',
  description: 'Track API calls per customer',
});

console.log(meter.id); // mtr_...

For a sum aggregation, specify the property to aggregate:

typescript
const meter = await client.meters.create({
  name: 'Token Usage',
  event_name: 'ai.tokens',
  aggregation: { type: 'sum', key: 'tokens' },
  measurement_unit: 'tokens',
});
List and Retrieve Meters
typescript
// List all meters
const meters = await client.meters.list();

// Retrieve a specific meter
const meter = await client.meters.retrieve('mtr_abc123');
Archive and Unarchive

Meters are archived, not deleted. Archived meters stop accepting new events but retain historical data.

typescript
// Archive a meter
await client.meters.archive('mtr_abc123');

// Unarchive to resume
await client.meters.unarchive('mtr_abc123');

Event Ingestion

Send Events
typescript
async function recordApiCall(
  customerId: string,
  requestId: string,
  occurredAt: string,
): Promise<number> {
  const response = await client.usageEvents.ingest({
    events: [{
      event_id: `api-call:${requestId}`,
      customer_id: customerId,
      event_name: 'api.call',
      timestamp: occurredAt,
      metadata: {
        endpoint: '/v1/users',
        method: 'GET',
      },
    }],
  });

  return response.ingested_count;
}

requestId must identify the underlying API operation and remain unchanged across retries. Do not generate it inside the ingestion attempt.

Event Schema
FieldRequiredNotes
event_idYesUnique identifier for idempotency. Duplicate IDs in the same request reject the entire request.
customer_idYesDodo Payments customer ID.
event_nameYesMust match a meter's event name exactly (case-sensitive).
timestampNoISO-8601 datetime. Defaults to current UTC time. Must be within one hour in the past or five minutes in the future.
metadataNoObject with string, integer, number, or boolean values. Max 50 pairs; key length 100, value length 500. No nested objects or arrays.
Idempotency and Deduplication
  • Each distinct operation gets one globally unique event_id.
  • Derive the ID from an immutable request, job, generation, or snapshot ID and reuse it on every retry.
  • Duplicate IDs in a single request reject the entire batch.
  • An ID already ingested in an earlier request is silently ignored, making retries safe.
Batch Ingestion

Send up to 1,000 events per request:

typescript
async function trackBatchUsage(
  events: Array<{
    operationId: string;
    customerId: string;
    eventName: string;
    occurredAt: string;
    metadata: Record<string, string | number | boolean>;
  }>
) {
  const formattedEvents = events.map((event) => ({
    event_id: `usage:${event.operationId}`,
    customer_id: event.customerId,
    event_name: event.eventName,
    timestamp: event.occurredAt,
    metadata: event.metadata,
  }));

  await client.usageEvents.ingest({ events: formattedEvents });
}

// Batch track multiple API calls
await trackBatchUsage([
  { operationId: 'req_101', customerId: 'cus_abc', eventName: 'api.call', occurredAt: '2026-08-01T10:00:00Z', metadata: { endpoint: '/v1/users' } },
  { operationId: 'req_102', customerId: 'cus_abc', eventName: 'api.call', occurredAt: '2026-08-01T10:00:01Z', metadata: { endpoint: '/v1/orders' } },
  { operationId: 'req_103', customerId: 'cus_xyz', eventName: 'api.call', occurredAt: '2026-08-01T10:00:02Z', metadata: { endpoint: '/v1/products' } },
]);
Query Events
typescript
// List events for a customer
const events = await client.usageEvents.list({
  customer_id: 'cus_abc123',
});

// Retrieve a specific event
const event = await client.usageEvents.retrieve('evt_abc123');

Pricing Models

Per-Unit Pricing

The only currently documented and operable pricing model. A meter attachment uses:

  • price_per_unit: decimal string (max 5 integer digits, 12 decimal places)
  • free_threshold: optional integer (usage below this is not charged)

Charge formula: (usage − threshold) × price_per_unit

The product-catalog-management skill is the canonical source for the complete product creation request. It defines the singular price object with type: 'usage_based_price' and its nested meters array; do not define a parallel product schema here.

Note: Tiered, graduated, volume, and staircase pricing models are not currently documented in the Dodo Payments API. Use per-unit pricing with free thresholds for now.

Instrumenting Your Application

Full guide: references/instrumentation.md.

Covers:

  • Track API Calls
  • Track AI Token Usage
  • Track Storage Usage

Querying Usage for Display

Show full SKILL.md (400 more words)Show less
Retrieve Usage History
typescript
// Auto-paginates across ALL billing periods; narrow with start_date/end_date/meter_id.
for await (const period of client.subscriptions.retrieveUsageHistory('sub_abc123', {
  start_date: '2025-01-01T00:00:00Z',
  page_size: 20,
})) {
  console.log(period); // one record per billing period, with per-meter usage
}

This is paginated usage history organized by billing period, across the subscription's lifetime - not just the current period. Filter with start_date, end_date, and meter_id, and iterate pages (or for await) rather than reading only the first page.

Credit-Based Billing Integration

Usage events can deduct from a customer's credit balance instead of charging per-unit. See the credit-based-billing skill for full details on credit entitlements, balances, and ledger management.

To link a meter to credits:

  1. Create a credit entitlement (e.g., "AI Credits").
  2. Attach the credit entitlement to the same product.
  3. On the meter, enable Bill usage in Credits.
  4. Set credit_entitlement_id and meter_units_per_credit (e.g., 1,000 tokens = 1 credit).

The free threshold does not apply to credit-billed meters: every unit counts toward credit deduction (it only applies when the meter bills in money). Approximately every minute, a background worker aggregates new usage, converts it using the meter-to-credit ratio, and deducts from non-expired grants, earliest-expiring grants consumed first. When credits run out, configured overage behavior applies.

Webhook Integration

Usage events trigger webhooks for monitoring and reconciliation. See the webhook-integration skill for webhook setup and verification.

Common Mistakes

1. Using Unstable or Reused Event IDs

Generate one ID from the immutable business operation. Reusing an ID for a different operation drops usage, while generating a timestamp or random ID on every retry can bill the same operation twice.

typescript
// WRONG — a retry creates a new billable event
await client.usageEvents.ingest({
  events: [{
    event_id: `api-call:${Date.now()}:${crypto.randomUUID()}`,
    customer_id: 'cus_abc',
    event_name: 'api.call',
  }],
});

// CORRECT — retry request req_123 with this same ID
await client.usageEvents.ingest({
  events: [{
    event_id: 'api-call:req_123',
    customer_id: 'cus_abc',
    event_name: 'api.call',
  }],
});

Do not reuse api-call:req_123 for a distinct request. This matches credit ledger guidance: a timeout is not permission to generate a fresh idempotency key.

2. Using Fire-and-Forget Ingestion

Do not start ingestion after responding without first persisting the event. The process can crash after the user receives success but before usage reaches Dodo.

typescript
// WRONG — an acknowledged operation can lose its usage event
app.post('/api/generate', async (req, res) => {
  const result = await generateAI(req.body);
  res.json(result);
  void client.usageEvents.ingest({ events: [result.usageEvent] });
});

// CORRECT — durable persistence completes before success is returned
app.post('/api/generate', async (req, res) => {
  const result = await generateAI(req.body);
  await usageOutbox.persist(result.usageEvent);
  res.json(result);
});

A retrying worker ingests the persisted payload with its original event_id, as shown in Track API Calls. If persistence fails, return an error so the operation can be retried rather than silently underbilling.

3. Clock Skew in Timestamps

Timestamps must be within one hour in the past or five minutes in the future. Ensure your server clock is synchronized.

typescript
// WRONG — timestamp is 2 hours old
const oldTime = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
await client.usageEvents.ingest({
  events: [{
    event_id: 'evt_123',
    customer_id: 'cus_abc',
    event_name: 'api.call',
    timestamp: oldTime, // Rejected
    metadata: {}
  }]
});

// CORRECT — use current time
await client.usageEvents.ingest({
  events: [{
    event_id: 'evt_123',
    customer_id: 'cus_abc',
    event_name: 'api.call',
    timestamp: new Date().toISOString(),
    metadata: {}
  }]
});
4. Ingesting on the Client Side

Never send events from client-side code. Always ingest from your backend to avoid exposing your API key.

typescript
// WRONG — client-side
const trackUsage = async (eventName: string) => {
  await fetch('https://test.dodopayments.com/events/ingest', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.DODO_PAYMENTS_API_KEY}`, // Exposed!
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ events: [...] })
  });
};

// CORRECT — send the event from a backend worker using its persisted payload
await client.usageEvents.ingest({
  events: [{
    event_id: 'api-call:req_123',
    customer_id: 'cus_abc',
    event_name: 'api.call',
    timestamp: '2026-08-01T10:30:00Z',
    metadata: { endpoint: '/v1/users' },
  }],
});
5. Mismatched Event Names

Event names are case-sensitive and must match the meter's event name exactly.

typescript
// WRONG — meter expects "api.call", event sends "API.CALL"
const meter = await client.meters.create({
  name: 'API Requests',
  event_name: 'api.call',
  aggregation: { type: 'count' },
  measurement_unit: 'calls',
});

await client.usageEvents.ingest({
  events: [{
    event_id: 'api-call:req_123',
    customer_id: 'cus_abc',
    event_name: 'API.CALL', // Won't match
  }]
});

// CORRECT
await client.usageEvents.ingest({
  events: [{
    event_id: 'api-call:req_123',
    customer_id: 'cus_abc',
    event_name: 'api.call', // Matches exactly
  }]
});

Resources

© hashgraph-online, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in plugins/dodopayments/dodo-agent-plugin/skills/usage-based-billing of hashgraph-online/awesome-codex-plugins.

  • SKILL.md
  • references/instrumentation.md

Open the folder on GitHubat commit 9e7b281

Compare with similar skills

Usage Based Billing next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Usage Based Billing compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Usage Based Billing this skillhashgraph-online/awesome-codex-plugins1.3k—~3.5kAutomated safety check: PassApache-2.0
Billing Automationwshobson/agents40k13 repos~473Automated safety check: PassMIT
Stripe Best Practicesfossasia/eventyay1.7k1 repos~1.7kAutomated safety check: PassApache-2.0
Pinme Uniwebpayglitternetwork/pinme3.7k—~7.3kAutomated safety check: PassMIT
PayRam Payment AnalyticsPayRam/payram-mcp158—~4.1kAutomated safety check: PassNone
Test Convt Serveropencoredev/convt258—~1.6kAutomated safety check: PassAGPL-3.0

Similar skills

  • Billing Automation

    wshobson/agents

    Covers building subscription billing: billing cycles, subscription states, invoice generation, proration, tax handling and dunning for failed payments.

    40k GitHub starsUsed in 13 repos~473 tokens
    Backend & APIsAuto-check passed

  • Stripe Best Practices

    fossasia/eventyay

    Guides Stripe integration decisions across development and test environment planning (separate sandboxes vs the shared test mode sandbox), API selection (Checkout Sessions vs PaymentIntents)…

    1.7k GitHub starsUsed in 1 repo~1.7k tokens
    Backend & APIsAuto-check passed

  • Pinme Uniwebpay

    glitternetwork/pinme

    A skill your agent uses when generating, modifying, or reviewing PinMe Worker (Cloudflare Worker TypeScript) code that accepts payments through UniwebPay — payment links, products/prices, checkout…

    3.7k GitHub stars~7.3k tokensUpdated 27 days ago
    Backend & APIsAuto-check passed

  • PayRam Payment Analytics

    PayRam/payram-mcp

    Queries a PayRam server's dashboard data through its REST APIs with a Bearer token: payment search, daily volume, unswept balances, sweep history and on-ramp metrics.

    158 GitHub stars~4.1k tokensUpdated today
    Backend & APIsAuto-check passed

  • Test Convt Server

    opencoredev/convt

    Run and verify the convt jobs API, Postgres queue, object storage, sandbox worker and metering locally.

    258 GitHub stars~1.6k tokensUpdated today
    Backend & APIsAuto-check passed

  • AWS Marketplace Metering

    aws/agent-toolkit-for-aws

    Official

    Deploys, queries, and debugs AWS Marketplace usage-based (PAYG) metering — the pipeline (ResolveCustomer, BatchMeterUsage, EventBridge via SAM) and querying/debugging metering records, statuses…

    2.8k GitHub stars~18k tokensUpdated today
    Backend & APIsAuto-check passed

More from hashgraph-online/awesome-codex-plugins

All 714 skills in this repo

  • Anime Reaction Gif

    hashgraph-online/awesome-codex-plugins

    Create original anime-style reaction stickers as looping GIFs and MP4 previews, using generated character pose sheets and timed key poses.

    1.3k GitHub stars~922 tokensUpdated today
    Auto-check passed

  • Calibredb

    hashgraph-online/awesome-codex-plugins

    Manage and query Calibre libraries with the calibredb CLI (local paths or Calibre Content server URLs).

    1.3k GitHub stars~1k tokensUpdated today
    Auto-check passed

  • Rust API Test Harness

    hashgraph-online/awesome-codex-plugins

    A skill your agent uses when adding, changing, testing, or debugging Rust HTTP APIs and services, especially when Codex needs black-box integration tests, random-port app startup, real database test…

    1.3k GitHub stars~1.7k tokensUpdated today
    Auto-check passed

  • Art

    hashgraph-online/awesome-codex-plugins

    Make a studio's game look like something at build time — a cover from a real frame of the game (free), painted covers, backdrops, textures and character plates from image models through the…

    1.3k GitHub stars~2.4k tokensUpdated today
    Auto-check passed

  • Calle

    hashgraph-online/awesome-codex-plugins

    Use CALL-E from Codex through the calle CLI. An agent skill from hashgraph-online/awesome-codex-plugins.

    1.3k GitHub stars~2.9k tokensUpdated today
    Auto-check passed

  • Game Balance Economy

    hashgraph-online/awesome-codex-plugins

    Balance game difficulty, resources, rewards, probability, progression, economies, and dominant strategies.

    1.3k GitHub stars~618 tokensUpdated today
    Auto-check passed

Categories

Questions about Usage Based Billing

What does Usage Based Billing do?

Dodo Payments usage-based billing that charges per measured unit, covering meters, usage event ingestion by eventname, aggregation, free thresholds, priceperunit, and metered subscriptions. Usage Based Billing is an agent skill from hashgraph-online/awesome-codex-plugins. Dodo Payments usage-based billing that charges per measured unit, covering meters, usage event ingestion by eventname, aggregation, free thresholds, priceperunit, and metered subscriptions.

When should I use Usage Based Billing?

Usage Based Billing fits situations like: billing per API call; sending usage events; adding metered pricing to a plan; use credit-based-billing for prepaid credit pools.

How do I install Usage Based Billing in Claude Code?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill usage-based-billing -a claude-code`. Or copy the skill folder (plugins/dodopayments/dodo-agent-plugin/skills/usage-based-billing in hashgraph-online/awesome-codex-plugins) into .claude/skills/usage-based-billing in your project. Claude Code loads it when a task matches its description.

How do I install Usage Based Billing in Codex?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill usage-based-billing -a codex`. Or copy the skill folder (plugins/dodopayments/dodo-agent-plugin/skills/usage-based-billing in hashgraph-online/awesome-codex-plugins) into .agents/skills/usage-based-billing in your project. Codex loads it when a task matches its description.

Can I use Usage Based Billing in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add hashgraph-online/awesome-codex-plugins --skill usage-based-billing -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/usage-based-billing, .gemini/skills/usage-based-billing, .github/skills/usage-based-billing and .opencode/skills/usage-based-billing in your project.

What does Usage Based Billing need to run?

Going by SKILL.md and its folder, Usage Based Billing needs credentials named DODO_PAYMENTS_API_KEY. Our summary lists: A credential in DODO_PAYMENTS_API_KEY.

Does Usage Based Billing access the network?

SKILL.md names 2 domains. In commands or code: test.dodopayments.com; the agent is likely to contact it when it follows the instructions. As links in the text: docs.dodopayments.com. This is read from the text; nothing was executed.

Is Usage Based Billing safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Usage Based Billing use?

Usage Based Billing is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Usage Based Billing use?

About 3.5k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 782 tokens, read only when the agent opens those files.

What are the alternatives to Usage Based Billing?

Skills that share tags, products or a category with Usage Based Billing: Billing Automation (wshobson/agents, 40k stars), Stripe Best Practices (fossasia/eventyay, 1.7k stars), Pinme Uniwebpay (glitternetwork/pinme, 3.7k stars) and PayRam Payment Analytics (PayRam/payram-mcp, 158 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Usage Based Billing?

hashgraph-online (a GitHub organization) maintains it in hashgraph-online/awesome-codex-plugins, which has 1,255 GitHub stars. The repository holds 714 skills in this directory. The repository was last updated on October 9, 2026.

Source: hashgraph-online/awesome-codex-plugins on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.