GET account/stats

Query Usage Statistics

January 31, 2026 (November 7, 2026)

What is recorded
Request Headers
Query Parameters
Responses
Reading a row
Totals
Large days
Job ends
Model names
Google Flow fields
Google Flow uploads
Model
Examples
Try It

Returns your requests to one API, one row each, with totals and counts per account, model, endpoint and status code. Use it to see what failed, why, and on which account.

Rows show up 5 to 15 minutes after the request.
Rows are kept for 3 months.

What is recorded

Recorded	Not recorded
Every generation you submit, whatever its outcome	Requests useapi.net answered itself without calling the AI service: validation errors, our limits, an account already marked broken, an unknown job id
The end of every background job, see Job ends	Successful calls that are not generations: lookups, adding an account, cancelling a job
Any other request the AI service failed or refused	Successful reads, such as polling a job
A request that failed or crashed inside useapi.net	Reads with a wrong id, such as polling a deleted job

These rules apply since November 1, 2026. Older rows followed earlier rules and have empty origin, outcome and error.

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.
`offset`	No	Page of a large day, see Large days: `0`, `20000`, `40000` and so on, as `page.next_offset` gives. Only with a day (`date`, or today), not with `limit`.
`config`	No	Filter by one service account, written exactly as it appears in the `config` field of the rows, for example an email. Letters, digits and `_ . @ + : % -` only, URL-encoded (`+` as `%2B`). Anything else answers `400`.

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,
    "account_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,
      "outcome": "ok",
      "error": "",
      "origin": "submit",
      "model": "imagen-4",
      "captchaProviders": "CapSolver",
      "captchaRetry": 1,
      "tier": "PAYGATE_TIER_TWO",
      "sku": "WS_ULTRA",
      "backend": "flow",
      "bytes": 0,
      "reason": "",
      "sampleInterval": 1
    }
  ]
}

The summary object is left out when there are no rows.

400 Bad Request

Missing or invalid parameters, for example a config that is not a plain account name.
```
{
  "error": "<error message>"
}
```
401 Unauthorized

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

Reading a row

Three fields say what a row is. They are empty on rows written before November 1, 2026.

`origin`	Why the row exists
`submit`	A generation you submitted (for `google-flow`, also a file upload)
`finished`	The end of a background job, see Job ends
`refused`	Another request that failed
`read`	A `GET` that failed
`crash`	A request that crashed inside useapi.net

`outcome`	What happened	Typical codes
`ok`	It worked	`2xx`
`customer`	A problem with the request or its content	`400`, `404`, `422` (content refused)
`account`	A problem with the service account	`401`, `402`, `403`, `429`, `596`
`vendor`	The AI service failed	`5xx` after the service was called, or a failure inside a `2xx` answer
`ours`	useapi.net failed	a crash, or a `5xx` before the service was called

error is the error text, written the same way every time so you can group by it: lowercase, with URLs, emails, ids and numbers masked (numbers become N), at most 120 characters. It is empty on success.

Totals

total, success_rate and avg_msec count submitted work only: rows with origin submit, plus older rows.
Other failed requests (refused, read, crash) are in data and the by_ counts, but not in those three figures.
Job ends have their own figures in summary.jobs, see below.
An MCP tool call shows as the REST request the tool makes. Rows with endpoint mcp, written until October 31, 2026, repeated those requests and are left out of total.

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.

Large days

A day with more than 50,000 rows comes in pages of 20,000, newest first. total and summary always cover the whole day, on every page.

The answer then has a page object: offset (the first row of this page), size (rows in data), rows (rows in the whole day) and next_offset. Ask for the next page with offset set to next_offset, and stop when it is missing. A day of 50,000 rows or fewer returns everything at once, with no page, unless you pass an offset above 0.

For today, rows keep arriving while you page, so a later page can repeat a few rows of the one before. Past days page exactly.

On a paged google-flow day before September 25, 2026, summary.model_refusals counts only the refusals recorded on the rows themselves, so success_rate can read slightly lower than on a smaller day.

Job ends

When a background job ends, a second row is written next to the submit row:

endpoint is the submit endpoint plus -finished, for example post-videos-finished (video-finished and image-finished for pixverse)
origin is finished, and status is the final status
code is 200 for a finished result, otherwise the job’s error code, for example 422 for a moderated pixverse job
msec is the time from submit to end (the submit row’s msec covers only the submit call)

Job ends stay out of total, success_rate, avg_msec and the by_ counts. summary.jobs counts them instead: finished, completed (finished results), completion_rate and avg_msec (submit to result, completed jobs only).

Written for pixverse since October 28, 2026 and for the other APIs since November 1, 2026. PixVerse Off-Peak videos have no end row.

Model names

model and by_model are filled for google-flow, dreamina, kling, minimax, pixverse, luma, gemini-notebook, google-vids and muse. Usually it is the AI model, such as veo-3.1-fast. Some requests use their own names:

API	`model`	Rows
`google-flow`	`agent`	Agent turns, their end rows (`completed`, `waiting_approval` or `failed`), and agent requests that failed
	`agent-approval`	An approval answered
	`agent-stream`	A chat stream that failed
	`mcp`	A crash inside the MCP server
`gemini-notebook`	the Studio action, for example `video:cinematic` or `quiz`	Studio work. Empty on chat and sources
`google-vids`	`video:text`, `video:image`, `video:ingredients`, `video:extend`, `video:upscale`, `video:edit`, `image`, `avatar:image`, `avatar:appearance`	What the request made. Empty on failed uploads
`muse`	`muse-image`, `muse-video`	Generations and their end rows
	`muse-chat`	Each chat message sent, and other chat requests that failed
	`muse-chat-approval`	An approval Muse did not take
	`muse-stream`	A chat stream that failed (status `failed` or `dropped`)
	`muse-widget`	A widget the API can only pass through as `data` (status is the widget kind)
	`muse-permissions`	A failed change to the agent’s permissions
	`muse-mcp`	A crash inside the MCP server
	`sign-in`	A failed sign-in (status `refused` or `failed`), or Meta’s security checkpoint on an added account (status `checkpoint`)
	`quota`	A failed live account read

muse rows also carry tier: the account’s Muse plan, for example HATCH_FREE (free) or PRODUCT_TIER_1 (Power). Empty before October 13, 2026.

Google Flow fields

Field	Meaning
`captchaProviders` / `by_captcha_provider`	Captcha providers used
`captchaRetry` / `avg_captcha_retry`	Captcha retries
`tier` / `by_tier`	Google plan family, for example `PAYGATE_TIER_TWO`. Since May 21, 2026
`sku` / `by_sku`	The exact subscription, for example `WS_ULTRA`. Since May 21, 2026
`summary.lookup`	Plan names for the `tier` and `sku` values present, for example `WS_ULTRA` → `Workspace Ultra`. Read names from here rather than hard-coding them
`backend`	`flow` (flow.google.com) or `labs` (the older backend). Since September 14, 2026, empty when the request failed before one was chosen
`reason` / `by_reason`	Google’s reason for refusing, for example `PUBLIC_ERROR_USER_QUOTA_REACHED`. Since September 25, 2026
`model_refusals`	Requests refused because the account’s plan does not offer the model (`PUBLIC_ERROR_MODEL_ACCESS_DENIED`). They say something about the account, so `success_rate` leaves them out
`account_refusals`	Requests refused because Google treats the Google account as belonging to someone under 18 (`PUBLIC_ERROR_USER_MINOR`). Google Flow refuses such an account whatever the request, so `success_rate` leaves them out too. Image uploads count from November 7, 2026
`bytes`	Size of an uploaded file, `0` on every other row

Rows without a plan (uploads, and rows from before May 21, 2026) count under "(empty)" in by_tier and by_sku. Before September 25, 2026, model_refusals are recovered from a sampled log, so a few older ones may still count against success_rate.

Invited members of an Ultra $199 family plan cannot use veo-3.1-lite-low-priority since September 23, 2026, and those requests count as model_refusals.

Known tier and sku values:

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

Google Flow uploads

Every upload that reaches Google writes a post-assets row (since September 19, 2026).

Uploads can be an account’s busiest call. With limit they can push generations out of the window, so ask for a date without limit and filter data by endpoint.
bytes is the size sent to Google, also on refused uploads. There is no summary field: add up bytes × sampleInterval over the post-assets rows.
Uploads refused before reaching Google (bad token, file too large, every account already upload-limited) write no row. Rows with code 200 are the uploads Google accepted.

Google limits uploads per account separately from generation. An account at the limit refuses every upload but still generates. The limit clears, so far within about two weeks. Counting post-assets rows per config shows how much of the allowance an account has used.

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
  page?: {                       // Only for a day of more than 50,000 rows, or an offset above 0 (see Large days)
    offset: number               // First row of this page
    size: number                 // Rows in data
    rows: number                 // Rows in the whole day
    next_offset?: number         // offset of the next page, missing on the last one
  }
  total: number                  // Generations the returned rows stand for (sum of sampleInterval over rows with origin submit or empty), on a paged day the whole day's; job ends, refused / read / crash rows and mcp rows are left out
  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 generations with a 2xx code (e.g., "86.7%"); google-flow leaves model_refusals and account_refusals out, and reports "n/a" when every row is one
    avg_msec: number             // Average response time of generations in ms
    jobs?: {                     // the job-end rows (endpoint <route>-finished), every API with background jobs
      finished: number
      completed: number          // finished results
      completion_rate: string
      avg_msec: number           // submit to finished result, completed jobs only
    }
    // the APIs listed under Model names:
    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)
    account_refusals?: number                    // Requests refused because Google treats the account as under 18; 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
    origin: string               // submit | finished | refused | read | crash; '' on rows written before 2026-11-01
    outcome: string              // ok | customer | account | vendor | ours; '' on rows written before 2026-11-01
    error: string                // normalised error text, URLs / emails / ids / numbers masked, <= 120 chars; '' on success and older rows
    // the APIs listed under Model names:
    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 Totals)
  }>
}

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"

# Second page of a large day (page.next_offset of the first page)
curl -H "Authorization: Bearer YOUR_API_TOKEN" \
     "https://api.useapi.net/v2/account/stats?bot=google-flow&date=2026-01-31&offset=20000"

# 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'])