GET account/stats

Query Usage Statistics

January 31, 2026 (October 16, 2026)

Request Headers
Query Parameters
Responses
Model
Examples
Try It

Query your API usage statistics. Returns detailed information about jobs/requests for a specific bot.

Note:

Data latency is at least 5 minutes, but should not exceed 15 minutes.
Data is retained for 3 months.

https://api.useapi.net/v2/account/stats

Request Headers

Authorization: Bearer {API token}

API token is required, see Setup useapi.net for details.

Query Parameters

Parameter	Required	Description
`bot`	Yes	Bot to query stats for. Supported: `google-flow`, `dreamina`, `kling`, `runwayml`, `pixverse`, `minimax`, `mureka`, `flowmusic`, `tempolor`, `ltxstudio`, `luma`, `gemini-notebook`, `google-vids`, `muse`
`date`	No	Date in `YYYY-MM-DD` format. Defaults to today if `limit` is not specified.
`limit`	No	Number of records to return (max: 50000). If specified, `date` filter is ignored and returns last N records across all dates.
`config`	No	Filter by specific config (channel/email/account depending on bot).

Responses

200 OK

Returns usage statistics for the specified bot.

{
  "bot": "google-flow",
  "date": "2026-02-13",
  "total": 2402,
  "summary": {
    "from": "2026-02-13T00:00:03.000Z",
    "to": "2026-02-13T23:58:38.000Z",
    "time_span": "23 hours 58 minutes",
    "by_config": {
      "[email protected]": 670,
      "[email protected]": 547,
      "[email protected]": 438,
      "[email protected]": 321,
      "[email protected]": 306,
      "[email protected]": 120
    },
    "by_code": {
      "200": 548,
      "201": 796,
      "400": 130,
      "403": 684,
      "429": 239,
      "500": 3,
      "503": 2
    },
    "by_endpoint": {
      "post-images": 1334,
      "post-videos": 1046,
      "post-videos-upscale": 22
    },
    "by_status": {
      "Created": 796,
      "OK": 548,
      "Forbidden": 684,
      "Too Many Requests": 239,
      "Bad Request": 130,
      "Internal Server Error": 3,
      "Service Unavailable": 2
    },
    "success_rate": "56.0%",
    "model_refusals": 0,
    "avg_msec": 17759,
    "by_model": {
      "veo-3.1-lite-low-priority": 1032,
      "nano-banana-pro": 702,
      "imagen-4": 449,
      "nano-banana": 181,
      "veo-3.1-fast": 14
    },
    "by_captcha_provider": {
      "CapSolver": 4856
    },
    "avg_captcha_retry": 2,
    "by_tier": {
      "PAYGATE_TIER_TWO": 1684,
      "PAYGATE_TIER_ONE": 612,
      "PAYGATE_TIER_NOT_PAID": 106
    },
    "by_sku": {
      "WS_ULTRA": 1430,
      "G1_TIER2": 254,
      "G1_TIER1": 612,
      "G1_FREEMIUM": 106
    },
    "lookup": {
      "tiers": {
        "PAYGATE_TIER_TWO": "Ultra $199",
        "PAYGATE_TIER_ONE": "Pro",
        "PAYGATE_TIER_NOT_PAID": "Free"
      },
      "skus": {
        "WS_ULTRA": "Workspace Ultra",
        "G1_TIER2": "Ultra $199",
        "G1_TIER1": "Pro",
        "G1_FREEMIUM": "Free"
      }
    }
  },
  "data": [
    {
      "timestamp": "2026-02-13T10:30:00.000Z",
      "jobid": "20260213103000-user:123-bot:google-flow",
      "config": "[email protected]",
      "endpoint": "post-images",
      "status": "OK",
      "func": "v1-google-flow-images",
      "code": 200,
      "msec": 5432,
      "model": "imagen-4",
      "captchaProviders": "CapSolver",
      "captchaRetry": 1,
      "tier": "PAYGATE_TIER_TWO",
      "sku": "WS_ULTRA",
      "backend": "flow",
      "bytes": 0,
      "reason": "",
      "sampleInterval": 1
    }
  ]
}

The summary object provides aggregated statistics (omitted if no data).

On busy days the stats store keeps a sample of the rows from the busiest API tokens rather than every row. Each row’s sampleInterval says how many requests it stands for. It is 1 for almost every customer and higher only for the busiest ones at peak hours.

total and every count, rate and average in summary already weight each row by its sampleInterval, so they reflect all of your requests. When you count rows in data yourself, add up sampleInterval rather than counting rows. limit counts stored rows, so total can be larger than limit.

For google-flow, dreamina, kling, minimax, pixverse, luma, gemini-notebook, google-vids and muse, additional fields are included in both data rows and summary:

model / by_model: AI model used for generation. For google-flow agent requests it is agent (each turn, with endpoint execute and status completed, waiting_approval or failed, and the agent’s other requests), agent-approval for an approval answered, agent-stream for each chat stream opened (status opened), and mcp for each MCP server tool call (status is the tool name, or failed). For gemini-notebook it is the Studio action, for example video:cinematic or quiz, and empty on chat and sources. For google-vids it is what the request made: video:text, video:image, video:ingredients, video:extend, video:upscale, video:edit, image, avatar:image or avatar:appearance, and empty on uploads. For muse it is muse-image or muse-video on generations, muse-chat for each chat message sent, muse-chat-approval for an approval answered from a chat, muse-stream for each chat stream opened (status opened, refused or failed), muse-widget for a widget kind the API can only pass through as data (status is the kind), muse-permissions when the agent’s permissions are changed (status updated or failed), muse-mcp for each MCP server tool call (status is the tool name, or failed), sign-in when an account is signed in, or meets Meta’s security checkpoint when added (status checkpoint), quota when a live account read failed, and empty on uploads and downloads.

For google-vids and muse, each generation counts once, when it finishes or fails, including generations that ran with async: true.

For google-flow only, except tier and sku, which muse returns too:

captchaProviders / by_captcha_provider: Captcha providers used
captchaRetry / avg_captcha_retry: Captcha retry attempts
tier / by_tier: Google userPaygateTier (plan family — PAYGATE_TIER_NOT_PAID / _ONE / _TIER1P5 / _TWO). Available since 2026-05-21. Rows written before that date have empty tier/sku, and so do upload rows (post-assets, see below) — all of them bucket under "(empty)". For muse it is the account’s Muse plan code, for example HATCH_FREE for the free plan or PRODUCT_TIER_1 for Power, and empty on rows written before October 13, 2026 and on MCP rows.
sku / by_sku: Google sku string (specific subscription — G1_FREEMIUM / G1_TIER1 / G1_TIER1P5 / G1_TIER2 / WS_FREEMIUM / WS_ULTRA). Always empty for muse.
backend: which Google backend served the call — flow for the flow.google.com path, labs for the older one. Empty on rows written before 2026-09-14, and on a call that failed before a backend was chosen.
reason / by_reason: Google’s own reason when it refused a request, for example PUBLIC_ERROR_MODEL_ACCESS_DENIED or PUBLIC_ERROR_USER_QUOTA_REACHED. Recorded since 2026-09-25 and empty on successful rows. Older rows show only plan refusals recovered from the captcha log.
model_refusals: requests Google refused because the account’s plan does not offer the model (PUBLIC_ERROR_MODEL_ACCESS_DENIED) — since 2026-09-23 that includes veo-3.1-lite-low-priority on invited members of an Ultra $199 family plan. These say something about the account, not about the service, so success_rate leaves them out. For rows written before 2026-09-25, when reason began to be recorded, refusals are recovered from the per-attempt captcha log. That log is sampled, so some older refusals may still count against success_rate. Rows from 2026-09-25 on are exact.
bytes: size of an uploaded file. See below — it is 0 on every row that is not post-assets.
summary.lookup.tiers / summary.lookup.skus: canonical enum → human-readable label map (e.g. WS_ULTRA → "Workspace Ultra"). Resolve enums through this map rather than hard-coding strings. Unknown enums map to themselves so new values aren’t lost.

Image and video uploads (google-flow)

Since 2026-09-19, POST /assets writes a row like every other endpoint, so image and video uploads appear in data and count under by_endpoint as post-assets. Three things to know when reading them:

An upload has no model, tier or sku, so those fields are empty on its rows, and it counts under "(empty)" in by_tier and by_sku.
Uploads are often the highest-volume call an account makes. There is no endpoint filter on this endpoint, so if you pass limit, uploads can fill the window and push generations out of it. Request a date without limit and filter data on endpoint yourself when you want one or the other.
bytes carries the size of the file sent to Google, recorded before the upload is attempted — so a refused upload reports the bytes Google declined. It is 0 on any row that is not post-assets, and 0 on an upload only when no body was read, which answers 400. There is no summary equivalent: sum bytes over data yourself, filtering on endpoint == "post-assets". Multiply each row’s bytes by its sampleInterval before adding them up, the same as any other count.
Not every request writes a row. Ones rejected before they reach the upload handler — an invalid token, or every account on your token already being upload-limited — write none, so this counts attempts that got as far as Google. For uploads Google actually accepted, count the rows with code 200.

These rows exist so you can count uploads per account. Google limits how many files an account may upload, separately from generation, and an account that reaches the limit refuses every upload while generating normally. The limit does clear. Accounts that reached it have uploaded again within about two weeks, and we can’t yet tell whether it resets on a timer or when the account’s monthly subscription renews. Watching post-assets per config tells you how much of an allowance an account has spent and when it is worth resting rather than replacing.

Known tier/sku values (google-flow)

Field	Enum value	Label	Plan
`tier`	`PAYGATE_TIER_NOT_PAID`	Free	Free tier
`tier`	`PAYGATE_TIER_ONE`	Pro	Google AI Pro
`tier`	`PAYGATE_TIER_TIER1P5`	Ultra $99	Google AI Ultra $99/mo
`tier`	`PAYGATE_TIER_TWO`	Ultra $199	Google AI Ultra $199/mo
`sku`	`G1_FREEMIUM`	Free	Google AI consumer Free
`sku`	`G1_TIER1`	Pro	Google AI consumer Pro
`sku`	`G1_TIER1P5`	Ultra $99	Google AI consumer Ultra $99
`sku`	`G1_TIER2`	Ultra $199	Google AI consumer Ultra $199
`sku`	`WS_FREEMIUM`	Workspace Free	Google Workspace, no AI add-on
`sku`	`WS_ULTRA`	Workspace Ultra	Google Workspace + AI Ultra add-on

400 Bad Request

Missing or invalid parameters.
```
{
  "error": "<error message>"
}
```
401 Unauthorized

Invalid API token.
```
{
  "error": "Unauthorized"
}
```

Model

// Response structure
{
  bot: string                    // Bot name
  date?: string                  // Date filter applied (YYYY-MM-DD)
  limit?: number                 // Limit filter applied
  config?: string                // Config filter applied
  total: number                  // Requests the returned rows stand for (sum of sampleInterval)
  summary?: {                    // Aggregated statistics (omitted if no data)
    from: string                 // Earliest timestamp (ISO 8601)
    to: string                   // Latest timestamp (ISO 8601)
    time_span: string            // Human readable duration (e.g., "2 days 5 hours")
    by_config: Record<string, number>    // Count per config/account
    by_code: Record<string, number>      // Count per HTTP status code
    by_endpoint: Record<string, number>  // Count per endpoint/verb
    by_status: Record<string, number>    // Count per job status
    success_rate: string         // Percentage of 2xx codes (e.g., "86.7%"); google-flow leaves model_refusals out, and reports "n/a" when every row is one
    avg_msec: number             // Average response time in ms
    // google-flow, dreamina, minimax:
    by_model?: Record<string, number>            // Count per AI model
    // google-flow only:
    by_captcha_provider?: Record<string, number>  // Count per captcha provider
    avg_captcha_retry?: number   // Average captcha retries
    by_reason?: Record<string, number>           // Count per Google refusal reason (google-flow, since 2026-09-25)
    model_refusals?: number                      // Requests refused because the account's plan lacks the model; not in success_rate (google-flow)
    by_tier?: Record<string, number>             // Count per Google userPaygateTier (since 2026-05-21). Pre-existing rows bucket under "(empty)".
    by_sku?: Record<string, number>              // Count per Google sku (since 2026-05-21). Pre-existing rows bucket under "(empty)".
    lookup?: {                                    // Canonical enum -> human-readable label map for the tier/sku values present here.
      tiers: Record<string, string>               // e.g. { PAYGATE_TIER_TWO: "Ultra $199" }. Unknown enums map to themselves.
      skus: Record<string, string>                // e.g. { WS_ULTRA: "Workspace Ultra" }. Unknown enums map to themselves.
    }
  }
  data: Array<{
    timestamp: string            // ISO 8601 timestamp
    jobid: string                // Job/task identifier
    config: string               // Account/config used (channel for MJ, email/account for others)
    endpoint: string             // API endpoint called
    status: string               // Job status
    func: string                 // Function name
    code: number                 // HTTP status code
    msec: number                 // Duration in milliseconds
    // google-flow, dreamina, minimax:
    model?: string               // AI model used for generation
    // google-flow only:
    captchaProviders?: string    // Captcha providers tried (comma-separated)
    captchaRetry?: number        // Number of captcha retries
    tier?: string                // Google userPaygateTier (PAYGATE_TIER_*). Empty for rows pre-2026-05-21. Resolve to a label via summary.lookup.tiers.
    sku?: string                 // Google sku (G1_*/WS_*). Empty for rows pre-2026-05-21. Resolve to a label via summary.lookup.skus.
    backend?: string             // "flow" | "labs" — which Google backend served it. Empty for rows pre-2026-09-14.
    reason?: string              // Google's refusal reason, e.g. "PUBLIC_ERROR_MODEL_ACCESS_DENIED". Empty on success. Before 2026-09-25 only plan refusals are filled in.
    bytes?: number               // Size of an uploaded file. 0 on every row that is not post-assets.
    sampleInterval: number       // How many requests this row stands for, usually 1 (see above)
  }>
}

Examples

# Today's stats for google-flow
curl -H "Authorization: Bearer YOUR_API_TOKEN" \
     "https://api.useapi.net/v2/account/stats?bot=google-flow"

# Specific date
curl -H "Authorization: Bearer YOUR_API_TOKEN" \
     "https://api.useapi.net/v2/account/stats?bot=google-flow&date=2026-01-31"

# Last 1000 records
curl -H "Authorization: Bearer YOUR_API_TOKEN" \
     "https://api.useapi.net/v2/account/stats?bot=kling&limit=1000"

# Filter by config
curl -H "Authorization: Bearer YOUR_API_TOKEN" \
     "https://api.useapi.net/v2/account/stats?bot=runwayml&[email protected]"

const token = 'YOUR_API_TOKEN';
const bot = 'google-flow';
const date = '2026-01-31';

const response = await fetch(
  `https://api.useapi.net/v2/account/stats?bot=${bot}&date=${date}`,
  {
    headers: {
      'Authorization': `Bearer ${token}`
    }
  }
);

const stats = await response.json();
console.log(`Total requests: ${stats.total}`);
console.log('Stats:', stats.data);

import requests

token = 'YOUR_API_TOKEN'
headers = {'Authorization': f'Bearer {token}'}

# Today's stats for google-flow
response = requests.get(
    'https://api.useapi.net/v2/account/stats',
    params={'bot': 'google-flow'},
    headers=headers
)
stats = response.json()
print(f"Total requests: {stats['total']}")
print('Stats:', stats['data'])