# Ollama Account Usage Checker

Ollama Account Usage Checker reads your Ollama Cloud API key through Ollama's official API and returns a usage report: session and weekly quota with reset times and a pace forecast on request-based plans, an exact monthly dollar meter on metered accounts, 30 days of daily usage, the last 10 hours hour by hour, and trend lines. It costs $0.02 per successful check, and failed checks are free.

## Key facts

- Price: from $0.02 per usage check, $20.00 per 1,000
- Pricing model: Pay per event
- Output: JSON, CSV, Excel, XML, RSS via Apify datasets
- Access: Apify Console, REST API, Python and JS clients
- Version: Updated Nov 2026, build 0.3.4
- Actor: subimpact/ollama-usage-checker

## Who it is for

- Developers watching an Ollama Cloud key against a session or weekly limit
- Teams on a metered plan tracking spend against included credits
- Operators scheduling daily usage history for capacity planning
- Anyone building an alert when a key approaches its cap

## Use cases

### See how close you are to the cap

Run in detailed mode and the windows section reports the session and weekly figures with exact reset times, plus a pace forecast that projects where you will land at reset. On request-based plans those percentages are estimates, calibrated on a real Pro account and labelled in windows.basis, so you can see the assumption behind the number rather than trusting a bare figure.

### Track spend on a metered plan

On dollar-metered accounts the monthly meter is exact: dollars used against the credits your plan includes, with the reset date. Because the report is a snapshot, schedule the check daily and keep each row to build a spend line that the dashboard's own view does not retain. The plan field records which tier the numbers belong to.

### Read the last 30 days

daily holds requests per day for 30 days, with USD and input and output tokens added on dollar-metered accounts. That is the series for a capacity question: whether volume is trending up week over week, which day was busiest, and whether a spike is one bad day or a change in usage. trends summarises the busiest day and the week-over-week change.

### Watch the current session hour by hour

The last 10 hours arrive hour by hour with a seven day sparkline, and peak hour and countdown to the next reset sit in trends. That is the view you want when a batch job is running and you need to know whether it will survive the session window or should be paced, rather than discovering a wall mid-run.

### Alert before you hit the limit

Schedule the Actor daily and keep maxItems at 1 per run, then wire a check on the session or weekly figure to a webhook. A failed check, whether the key is invalid, Ollama is unavailable or the response shape changed, returns ok false with an error code and costs nothing, so a broken key does not quietly look like low usage.

## Price events

- Usage check (`usage-check`): $0.02, lowest tier $0.02. Full account usage report for one Ollama API key

Prices from the Apify Store. Apify shows the final price before each run.

## How it compares with other Apify actors

No candidate reads account usage from an AI provider key. The nearby actors call AI models, moderate images or track brand mentions, so none shares this source, this data or this per check unit, and a comparison table would be meaningless.

## Input

- `apiKey` (string, required): Your Ollama Cloud API key (sk-...). Stored as a SECRET input — encrypted at rest, never logged, never written to the dataset. Only the masked form appears in output.
- `mode` (string, optional): detailed (default): full report, including 30-day daily usage, hourly usage, quota windows and trends. quick: headline numbers only (totals, session/weekly % or monthly meter, reset times).

### Example input

```json
{
  "mode": "detailed"
}
```

## Output fields

- `ok` (boolean): true when the key was accepted and usage fetched
- `error` (string/null): invalid_key | ollama_<status> | bad_response | network | ollama_shape_changed (failed runs are not charged)
- `message` (string/null): Human-readable explanation when ok is false
- `key_masked` (string/null): First 4 + last 4 characters of the API key
- `plan` (string/null): Ollama plan (free / pro / max / team)
- `email` (string/null): 
- `account` (object/null): created_at, days_old, username, first_name, last_name
- `usage` (object/null): total_30d {requests, usage_usd} and total_24h {requests}
- `days` (array/null): [{day, requests, usage_usd, input_tokens, output_tokens}]
- `hours` (array/null): [{hour_label, requests}]
- `sparkline` (string/null): Unicode bars over the last 7 days of requests
- `analytics` (object/null): busiest_day, wow_pct (week over week), peak_hour, session.resets_in_min
- `windows` (object/null): account_type, session/weekly estimated % with reset times and pace (request accounts), exact monthly $ meter vs included credits (dollar accounts), basis
- `checked_at` (string/null): ISO timestamp of the check

## How to run it

1. Paste your Ollama Cloud API key into apiKey; it is stored as a secret input and only ever appears masked like 2890••••NpuE.
2. Leave mode at detailed for the full report, or set it to quick for headline numbers and reset times only.
3. Start the run in the Apify Console; it takes about 10 seconds because the two usage reads are spaced 8 seconds apart.
4. Open the dataset item and read ok, plan and windows first, then daily and hourly for the series.
5. Schedule the run daily if you want a stored usage history, and export as JSON, CSV or Excel.

### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/subimpact~ollama-usage-checker/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"detailed"}'
```

### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/ollama-usage-checker").call(run_input={
      "mode": "detailed"
    })

for item in client.dataset(run["default_dataset_id"]).iterate_items():
    print(item)
```

### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/ollama-usage-checker').call({
  "mode": "detailed"
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

### n8n

Use the Apify node (Run an Actor).
Actor ID: subimpact/ollama-usage-checker
Input JSON: paste the example input below.

## Limits

- Session and weekly percentages are estimates on request-based plans, since Ollama no longer returns quota percentages.
- A check takes about 10 seconds because Ollama allows only around five usage reads per minute.
- One check covers one API key, so several keys need several runs.
- The report is a snapshot; history exists only if you store the rows yourself.

## FAQ

### What does a check cost?

$0.02 per successful check. Failed checks are free: an invalid key, Ollama being unavailable or an unrecognised response all return ok false with an error code and no charge. A run takes about 10 seconds because Ollama allows around five usage reads a minute.

### Is my API key stored or logged?

The key is a secret input, encrypted at rest, never logged and never written to the dataset. The output carries only the masked form, first four and last four characters, in key_masked, so a report can be shared without exposing the credential.

### Are the quota percentages exact?

Not on request-based plans. Since 7 October 2026 Ollama's API returns request counts rather than quota percentages, so session and weekly figures are estimates calibrated on a real Pro account, and every report states that basis in windows.basis. The monthly meter on dollar-metered accounts is exact.

### What is in the 30 day section?

Requests per day for 30 days, with USD and input and output tokens added on dollar-metered accounts. The hourly section covers the last 10 hours, and a seven day sparkline gives a compact sense of shape across the week.

### Does it use the official API?

Yes. It reads your account usage through Ollama's official API, with no scraping of the web dashboard and no stored session. The output matches what the usage page reports, in a machine-readable row.

### Can I use it for alerting?

That is the common pattern: schedule a daily run, read the session or weekly figure from the dataset and trigger a webhook when it crosses your threshold. Because failures are explicit error codes rather than silent zeroes, an alert pipeline can distinguish a real low usage day from a broken key.

### Does quick mode cost less?

No, the event price is the same per check. quick simply returns headline numbers, totals, session and weekly figures or the monthly meter, and the reset times, without the 30 day daily series, the hourly detail and the trends.

## Links

- Page: https://subimpact.net/apis/ollama-usage-checker/
- Category: https://subimpact.net/apis/category/ai-developer/
- Run on Apify: https://apify.com/subimpact/ollama-usage-checker
- All data APIs: https://subimpact.net/apis/
- Catalogue JSON: https://subimpact.net/apis/catalogue.json
