AI APIの料金をリクエスト単位で計算する方法｜トークン使用量をDBへ保存

入力料金
= 10,000 ÷ 1,000,000 × $1
= $0.01

出力料金
= 2,000 ÷ 1,000,000 × $6
= $0.012

合計
= $0.022

通常入力
キャッシュ読み込み
キャッシュ書き込み

{
  "input_tokens": 10000,
  "input_tokens_details": {
    "cached_tokens": 4000,
    "cache_write_tokens": 2000
  },
  "output_tokens": 1000
}

10,000 - 4,000 - 2,000
= 4,000トークン

4,000 ÷ 1,000,000 × $0.20
= $0.0008

4,000 ÷ 1,000,000 × $0.02
= $0.00008

2,000 ÷ 1,000,000 × $0.25
= $0.0005

1,000 ÷ 1,000,000 × $1.20
= $0.0012

$0.0008
+ $0.00008
+ $0.0005
+ $0.0012
= $0.00258

{
  "usage": {
    "input_tokens": 75,
    "output_tokens": 1186,
    "output_tokens_details": {
      "reasoning_tokens": 1024
    },
    "total_tokens": 1261
  }
}

const billableOutputTokens =
  outputTokens + reasoningTokens;

const billableOutputTokens =
  outputTokens;

{
  "currency": "USD",
  "unit": "per_1m_tokens",
  "input": "2",
  "cached_input": "0.20",
  "cache_write_5m": "2.50",
  "cache_write_1h": "4",
  "output": "10",
  "effective_from": "2026-08-01"
}

console.log(0.1 + 0.2);

0.30000000000000004

npm install decimal.js

type ProviderName =
  | "openai"
  | "anthropic"
  | "gemini";

type NormalizedUsage = {
  provider: ProviderName;
  model: string;

  inputTokens: number;
  uncachedInputTokens: number;
  cachedInputTokens: number;

  cacheWriteTokens: number;
  cacheWrite5mTokens: number;
  cacheWrite1hTokens: number;

  outputTokens: number;
  reasoningTokens: number;

  totalTokens: number;
};

type PriceSnapshot = {
  currency: "USD";
  unitTokens: 1_000_000;

  inputPerUnit: string;
  cachedInputPerUnit: string;

  cacheWritePerUnit: string;
  cacheWrite5mPerUnit: string;
  cacheWrite1hPerUnit: string;

  outputPerUnit: string;

  pricingVersion: string;
};

import Decimal from "decimal.js";

type CostBreakdown = {
  inputCostUsd: string;
  cachedInputCostUsd: string;
  cacheWriteCostUsd: string;
  outputCostUsd: string;
  totalCostUsd: string;
};

function tokenCost(
  tokens: number,
  pricePerMillion: string,
): Decimal {
  return new Decimal(tokens)
    .mul(pricePerMillion)
    .div(1_000_000);
}

function calculateCost(
  usage: NormalizedUsage,
  price: PriceSnapshot,
): CostBreakdown {
  const inputCost =
    tokenCost(
      usage.uncachedInputTokens,
      price.inputPerUnit,
    );

  const cachedInputCost =
    tokenCost(
      usage.cachedInputTokens,
      price.cachedInputPerUnit,
    );

  const genericCacheWriteCost =
    tokenCost(
      usage.cacheWriteTokens,
      price.cacheWritePerUnit,
    );

  const cacheWrite5mCost =
    tokenCost(
      usage.cacheWrite5mTokens,
      price.cacheWrite5mPerUnit,
    );

  const cacheWrite1hCost =
    tokenCost(
      usage.cacheWrite1hTokens,
      price.cacheWrite1hPerUnit,
    );

  const cacheWriteCost =
    genericCacheWriteCost
      .plus(cacheWrite5mCost)
      .plus(cacheWrite1hCost);

  const outputCost =
    tokenCost(
      usage.outputTokens,
      price.outputPerUnit,
    );

  const totalCost =
    inputCost
      .plus(cachedInputCost)
      .plus(cacheWriteCost)
      .plus(outputCost);

  return {
    inputCostUsd:
      inputCost.toFixed(12),

    cachedInputCostUsd:
      cachedInputCost.toFixed(12),

    cacheWriteCostUsd:
      cacheWriteCost.toFixed(12),

    outputCostUsd:
      outputCost.toFixed(12),

    totalCostUsd:
      totalCost.toFixed(12),
  };
}

import OpenAI from "openai";

function normalizeOpenAIUsage(
  response: OpenAI.Responses.Response,
): NormalizedUsage {
  const usage = response.usage;

  const inputTokens =
    usage?.input_tokens ?? 0;

  const cachedInputTokens =
    usage?.input_tokens_details
      ?.cached_tokens ?? 0;

  const cacheWriteTokens =
    usage?.input_tokens_details
      ?.cache_write_tokens ?? 0;

  const uncachedInputTokens =
    Math.max(
      0,
      inputTokens -
        cachedInputTokens -
        cacheWriteTokens,
    );

  const outputTokens =
    usage?.output_tokens ?? 0;

  const reasoningTokens =
    usage?.output_tokens_details
      ?.reasoning_tokens ?? 0;

  return {
    provider: "openai",
    model: response.model,

    inputTokens,
    uncachedInputTokens,
    cachedInputTokens,

    cacheWriteTokens,
    cacheWrite5mTokens: 0,
    cacheWrite1hTokens: 0,

    outputTokens,
    reasoningTokens,

    totalTokens:
      usage?.total_tokens ??
      inputTokens + outputTokens,
  };
}

const gpt56LunaPrice:
  PriceSnapshot = {
  currency: "USD",
  unitTokens: 1_000_000,

  inputPerUnit: "0.20",
  cachedInputPerUnit: "0.02",

  cacheWritePerUnit: "0.25",
  cacheWrite5mPerUnit: "0",
  cacheWrite1hPerUnit: "0",

  outputPerUnit: "1.20",

  pricingVersion:
    "openai:gpt-5.6-luna:2026-07-30",
};

total_input_tokens
=
input_tokens
+ cache_creation_input_tokens
+ cache_read_input_tokens

{
  "usage": {
    "input_tokens": 2048,
    "cache_read_input_tokens": 1800,
    "cache_creation_input_tokens": 248,
    "output_tokens": 503,
    "cache_creation": {
      "ephemeral_5m_input_tokens": 148,
      "ephemeral_1h_input_tokens": 100
    }
  }
}

import Anthropic from "@anthropic-ai/sdk";

function normalizeClaudeUsage(
  message: Anthropic.Message,
): NormalizedUsage {
  const usage = message.usage;

  const regularInputTokens =
    usage.input_tokens;

  const cachedInputTokens =
    usage.cache_read_input_tokens ??
    0;

  const cacheWrite5mTokens =
    usage.cache_creation
      ?.ephemeral_5m_input_tokens ??
    0;

  const cacheWrite1hTokens =
    usage.cache_creation
      ?.ephemeral_1h_input_tokens ??
    0;

  const cacheWriteTokens =
    cacheWrite5mTokens +
    cacheWrite1hTokens;

  const inputTokens =
    regularInputTokens +
    cachedInputTokens +
    cacheWriteTokens;

  const outputTokens =
    usage.output_tokens;

  return {
    provider: "anthropic",
    model: message.model,

    inputTokens,
    uncachedInputTokens:
      regularInputTokens,
    cachedInputTokens,

    cacheWriteTokens: 0,
    cacheWrite5mTokens,
    cacheWrite1hTokens,

    outputTokens,
    reasoningTokens: 0,

    totalTokens:
      inputTokens +
      outputTokens,
  };
}

const claudeSonnet5AugustPrice:
  PriceSnapshot = {
  currency: "USD",
  unitTokens: 1_000_000,

  inputPerUnit: "2",
  cachedInputPerUnit: "0.20",

  cacheWritePerUnit: "0",
  cacheWrite5mPerUnit: "2.50",
  cacheWrite1hPerUnit: "4",

  outputPerUnit: "10",

  pricingVersion:
    "anthropic:claude-sonnet-5:through-2026-08-31",
};

通常入力
=
promptTokenCount
- cachedContentTokenCount

出力
=
candidatesTokenCount
+ thoughtsTokenCount

type GeminiUsageMetadata = {
  promptTokenCount?: number;
  cachedContentTokenCount?: number;
  candidatesTokenCount?: number;
  thoughtsTokenCount?: number;
  totalTokenCount?: number;
};

function normalizeGeminiUsage(
  model: string,
  usage:
    GeminiUsageMetadata | undefined,
): NormalizedUsage {
  const inputTokens =
    usage?.promptTokenCount ?? 0;

  const cachedInputTokens =
    usage?.cachedContentTokenCount ??
    0;

  const uncachedInputTokens =
    Math.max(
      0,
      inputTokens -
        cachedInputTokens,
    );

  const visibleOutputTokens =
    usage?.candidatesTokenCount ??
    0;

  const reasoningTokens =
    usage?.thoughtsTokenCount ??
    0;

  const outputTokens =
    visibleOutputTokens +
    reasoningTokens;

  return {
    provider: "gemini",
    model,

    inputTokens,
    uncachedInputTokens,
    cachedInputTokens,

    cacheWriteTokens: 0,
    cacheWrite5mTokens: 0,
    cacheWrite1hTokens: 0,

    outputTokens,
    reasoningTokens,

    totalTokens:
      usage?.totalTokenCount ??
      inputTokens +
        outputTokens,
  };
}

const gemini35FlashPrice:
  PriceSnapshot = {
  currency: "USD",
  unitTokens: 1_000_000,

  inputPerUnit: "1.50",
  cachedInputPerUnit: "0.15",

  cacheWritePerUnit: "0",
  cacheWrite5mPerUnit: "0",
  cacheWrite1hPerUnit: "0",

  outputPerUnit: "9",

  pricingVersion:
    "google:gemini-3.5-flash:standard:2026-08-09",
};

CREATE TABLE ai_api_usage (
  id BIGSERIAL PRIMARY KEY,

  trace_id UUID NOT NULL,

  provider VARCHAR(32) NOT NULL,
  model VARCHAR(128) NOT NULL,

  provider_request_id VARCHAR(255),

  operation VARCHAR(100),
  user_id VARCHAR(255),

  status VARCHAR(32) NOT NULL,

  input_tokens BIGINT NOT NULL DEFAULT 0,
  uncached_input_tokens BIGINT NOT NULL DEFAULT 0,
  cached_input_tokens BIGINT NOT NULL DEFAULT 0,

  cache_write_tokens BIGINT NOT NULL DEFAULT 0,
  cache_write_5m_tokens BIGINT NOT NULL DEFAULT 0,
  cache_write_1h_tokens BIGINT NOT NULL DEFAULT 0,

  output_tokens BIGINT NOT NULL DEFAULT 0,
  reasoning_tokens BIGINT NOT NULL DEFAULT 0,
  total_tokens BIGINT NOT NULL DEFAULT 0,

  input_cost_usd NUMERIC(20, 12) NOT NULL DEFAULT 0,
  cached_input_cost_usd NUMERIC(20, 12) NOT NULL DEFAULT 0,
  cache_write_cost_usd NUMERIC(20, 12) NOT NULL DEFAULT 0,
  output_cost_usd NUMERIC(20, 12) NOT NULL DEFAULT 0,

  estimated_cost_usd NUMERIC(20, 12) NOT NULL DEFAULT 0,

  pricing_version VARCHAR(255) NOT NULL,
  pricing_snapshot JSONB NOT NULL,
  usage_raw JSONB NOT NULL,

  latency_ms INTEGER,

  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

user_01JABC...

import {
  randomUUID,
} from "node:crypto";
import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function generateText(
  userId: string,
  prompt: string,
) {
  const traceId =
    randomUUID();

  const startedAt =
    performance.now();

  const response =
    await openai.responses.create({
      model: "gpt-5.6-luna",
      input: prompt,
    });

  const latencyMs =
    Math.round(
      performance.now() -
        startedAt,
    );

  const usage =
    normalizeOpenAIUsage(
      response,
    );

  const cost =
    calculateCost(
      usage,
      gpt56LunaPrice,
    );

  await saveAiUsage({
    traceId,
    userId,
    providerRequestId:
      response._request_id ??
      null,
    operation: "chat",
    status:
      response.status,
    usage,
    cost,
    price:
      gpt56LunaPrice,
    rawUsage:
      response.usage ??
      {},
    latencyMs,
  });

  return response.output_text;
}

npm install pg decimal.js
npm install -D @types/pg

import {
  Pool,
} from "pg";

const pool = new Pool({
  connectionString:
    process.env.DATABASE_URL,
});

type SaveAiUsageInput = {
  traceId: string;
  userId: string;
  providerRequestId:
    string | null;
  operation: string;
  status: string;

  usage: NormalizedUsage;
  cost: CostBreakdown;
  price: PriceSnapshot;

  rawUsage: unknown;
  latencyMs: number;
};

async function saveAiUsage(
  input: SaveAiUsageInput,
): Promise<void> {
  await pool.query(
    `
      INSERT INTO ai_api_usage (
        trace_id,
        provider,
        model,
        provider_request_id,
        operation,
        user_id,
        status,

        input_tokens,
        uncached_input_tokens,
        cached_input_tokens,

        cache_write_tokens,
        cache_write_5m_tokens,
        cache_write_1h_tokens,

        output_tokens,
        reasoning_tokens,
        total_tokens,

        input_cost_usd,
        cached_input_cost_usd,
        cache_write_cost_usd,
        output_cost_usd,
        estimated_cost_usd,

        pricing_version,
        pricing_snapshot,
        usage_raw,

        latency_ms
      )
      VALUES (
        $1, $2, $3, $4, $5, $6, $7,
        $8, $9, $10,
        $11, $12, $13,
        $14, $15, $16,
        $17, $18, $19, $20, $21,
        $22, $23::jsonb, $24::jsonb,
        $25
      )
    `,
    [
      input.traceId,
      input.usage.provider,
      input.usage.model,
      input.providerRequestId,
      input.operation,
      input.userId,
      input.status,

      input.usage.inputTokens,
      input.usage
        .uncachedInputTokens,
      input.usage
        .cachedInputTokens,

      input.usage
        .cacheWriteTokens,
      input.usage
        .cacheWrite5mTokens,
      input.usage
        .cacheWrite1hTokens,

      input.usage.outputTokens,
      input.usage.reasoningTokens,
      input.usage.totalTokens,

      input.cost.inputCostUsd,
      input.cost
        .cachedInputCostUsd,
      input.cost
        .cacheWriteCostUsd,
      input.cost.outputCostUsd,
      input.cost.totalCostUsd,

      input.price.pricingVersion,
      JSON.stringify(
        input.price,
      ),
      JSON.stringify(
        input.rawUsage,
      ),

      input.latencyMs,
    ],
  );
}

CREATE UNIQUE INDEX
  ai_api_usage_provider_request_unique
ON ai_api_usage (
  provider,
  provider_request_id
)
WHERE provider_request_id IS NOT NULL;

ON CONFLICT (
  provider,
  provider_request_id
)
WHERE provider_request_id IS NOT NULL
DO NOTHING

completed
incomplete
failed
cancelled

trace_id: abc

OpenAI
status: incomplete
cost: $0.008

Claude
status: completed
cost: $0.015

SELECT
  trace_id,
  SUM(estimated_cost_usd)
    AS total_cost_usd
FROM ai_api_usage
GROUP BY trace_id;

SELECT
  user_id,
  SUM(estimated_cost_usd)
    AS cost_usd,
  SUM(input_tokens)
    AS input_tokens,
  SUM(output_tokens)
    AS output_tokens,
  COUNT(*)
    AS api_requests
FROM ai_api_usage
WHERE
  created_at >= DATE '2026-08-01'
  AND created_at < DATE '2026-09-01'
GROUP BY user_id
ORDER BY cost_usd DESC;

chat
article_generation
summarization
translation
rag_answer
code_review
classification

SELECT
  operation,
  provider,
  model,

  COUNT(*) AS requests,

  SUM(estimated_cost_usd)
    AS cost_usd,

  AVG(estimated_cost_usd)
    AS average_cost_usd

FROM ai_api_usage

WHERE
  created_at >= NOW()
    - INTERVAL '30 days'

GROUP BY
  operation,
  provider,
  model

ORDER BY
  cost_usd DESC;

SELECT
  operation,

  AVG(estimated_cost_usd)
    AS average_cost,

  PERCENTILE_CONT(0.5)
    WITHIN GROUP (
      ORDER BY estimated_cost_usd
    )
    AS median_cost,

  PERCENTILE_CONT(0.95)
    WITHIN GROUP (
      ORDER BY estimated_cost_usd
    )
    AS p95_cost,

  MAX(estimated_cost_usd)
    AS max_cost

FROM ai_api_usage

WHERE
  created_at >= NOW()
    - INTERVAL '30 days'

GROUP BY operation;

SELECT
  model,

  SUM(input_tokens)
    AS input_tokens,

  SUM(cached_input_tokens)
    AS cached_tokens,

  SUM(cache_write_tokens)
    AS cache_write_tokens,

  SUM(estimated_cost_usd)
    AS cost_usd

FROM ai_api_usage

WHERE
  provider = 'openai'
  AND created_at >= NOW()
    - INTERVAL '7 days'

GROUP BY model;

CREATE TABLE ai_model_prices (
  id BIGSERIAL PRIMARY KEY,

  provider VARCHAR(32) NOT NULL,
  model VARCHAR(128) NOT NULL,
  service_tier VARCHAR(64) NOT NULL,

  input_per_million
    NUMERIC(20, 8) NOT NULL,

  cached_input_per_million
    NUMERIC(20, 8) NOT NULL,

  cache_write_per_million
    NUMERIC(20, 8) NOT NULL,

  cache_write_5m_per_million
    NUMERIC(20, 8) NOT NULL,

  cache_write_1h_per_million
    NUMERIC(20, 8) NOT NULL,

  output_per_million
    NUMERIC(20, 8) NOT NULL,

  effective_from
    TIMESTAMPTZ NOT NULL,

  effective_until
    TIMESTAMPTZ,

  pricing_version
    VARCHAR(255) NOT NULL UNIQUE
);

SELECT *
FROM ai_model_prices
WHERE
  provider = $1
  AND model = $2
  AND service_tier = $3
  AND effective_from <= NOW()
  AND (
    effective_until IS NULL
    OR effective_until > NOW()
  )
ORDER BY effective_from DESC
LIMIT 1;

provider
model
service_tier
batch
region
pricing_version

AI API料金
=
入力トークン料金
+ キャッシュ料金
+ 出力トークン料金
+ ツール料金
+ キャッシュ保存料金
+ その他の従量料金

CREATE TABLE ai_api_extra_costs (
  id BIGSERIAL PRIMARY KEY,

  ai_usage_id BIGINT NOT NULL
    REFERENCES ai_api_usage(id),

  cost_type VARCHAR(100)
    NOT NULL,

  quantity
    NUMERIC(20, 8)
    NOT NULL,

  unit_price_usd
    NUMERIC(20, 12)
    NOT NULL,

  cost_usd
    NUMERIC(20, 12)
    NOT NULL,

  metadata JSONB NOT NULL
    DEFAULT '{}'::jsonb
);

SELECT
  user_id,
  SUM(estimated_cost_usd)
    AS ai_cost_usd

FROM ai_api_usage

WHERE
  created_at >=
    DATE_TRUNC(
      'month',
      CURRENT_DATE
    )

GROUP BY user_id;

const MAX_REQUEST_COST_USD =
  new Decimal("0.50");

const requestCost =
  new Decimal(
    cost.totalCostUsd,
  );

if (
  requestCost.greaterThan(
    MAX_REQUEST_COST_USD,
  )
) {
  console.warn({
    event:
      "high_ai_request_cost",
    traceId,
    provider:
      usage.provider,
    model:
      usage.model,
    costUsd:
      cost.totalCostUsd,
  });
}

SELECT
  SUM(estimated_cost_usd)
    AS today_cost_usd

FROM ai_api_usage

WHERE
  created_at >=
    CURRENT_DATE;

SELECT
  SUM(estimated_cost_usd)
    AS user_month_cost_usd

FROM ai_api_usage

WHERE
  user_id = $1
  AND created_at >=
    DATE_TRUNC(
      'month',
      CURRENT_DATE
    );