# Cost Implications of Live vs Queued Rank Checking in OpenSEO: A Complete Pricing Guide

> Understand the cost implications of live vs queued rank checking in OpenSEO. Queued checks are 30% cheaper and ensure results with automatic live fallbacks. Optimize your automated monitoring today.

- Repository: [Every App/open-seo](https://github.com/every-app/open-seo)
- Tags: pricing-guide
- Published: 2026-06-26

---

**Queued rank checking costs approximately 30% of live checks ($0.0006 versus $0.002 per first page) while still guaranteeing results through automatic live fallbacks, making it the optimal choice for automated monitoring.**

OpenSEO integrates with DataForSEO to monitor keyword rankings, offering two distinct execution methods that directly impact your billing. Understanding the **cost implications of live versus queued rank checking** is essential for optimizing your SEO monitoring budget without sacrificing data reliability. The system dynamically selects between immediate live requests and asynchronous queued tasks based on trigger type, with pricing structures defined in [`src/shared/rank-tracking.ts`](https://github.com/every-app/open-seo/blob/main/src/shared/rank-tracking.ts) designed to reward automated workflows.

## Live Rank Checking Pricing

Live methods provide instant results but command premium pricing. According to [`src/shared/rank-tracking.ts`](https://github.com/every-app/open-seo/blob/main/src/shared/rank-tracking.ts) (lines 12-16), the DataForSEO live endpoint costs:

- **First page** (10 results): **$0.002** per request
- **Additional pages**: **$0.0015** each (75% of base rate)

This method is triggered automatically for manual "check now" requests or when queued tasks fail to complete within the polling window.

## Queued Rank Checking Pricing

Queued methods leverage DataForSEO's standard task queue for bulk processing at significantly reduced rates. As implemented in [`src/shared/rank-tracking.ts`](https://github.com/every-app/open-seo/blob/main/src/shared/rank-tracking.ts) (lines 18-22):

- **First page** (10 results): **$0.0006** per request  
- **Additional pages**: **$0.00045** each (75% of base rate)

This represents roughly **70% savings** compared to live checks, making it ideal for scheduled daily or weekly monitoring workflows.

## How Rank Check Costs Are Calculated

The `estimateRankCheckCredits` function in [`src/shared/rank-tracking.ts`](https://github.com/every-app/open-seo/blob/main/src/shared/rank-tracking.ts) determines the total cost by multiplying three factors:

1. **Keyword volume** × **Device count** (desktop, mobile, or both) via `devicesCount()` (lines 28-30)
2. **Cost per SERP request** based on method (`live` or `queued`) via `costPerSerpAtDepth()` (lines 46-52)
3. **SEO data markup** and billing rounding via `roundUsdForBilling`

The function returns both USD and internal credit units (derived from `AUTUMN_SEO_DATA_CREDITS_PER_USD`).

```typescript
// Example from the codebase
const { costUsd, costCredits } = estimateRankCheckCredits(
  keywordCount,
  devices,
  serpDepth,
  method, // "live" or "queued"
);

```

In [`src/server/workflows/RankCheckWorkflow.ts`](https://github.com/every-app/open-seo/blob/main/src/server/workflows/RankCheckWorkflow.ts) (lines 80-89), scheduled runs always estimate costs using the queued price to validate credit balances against the lower threshold, while manual checks force the `"live"` method for immediate results.

## Billing Flow for Queued Checks

The queued workflow follows a multi-stage billing process defined in [`src/server/workflows/rankCheckPaths.ts`](https://github.com/every-app/open-seo/blob/main/src/server/workflows/rankCheckPaths.ts) and [`src/server/lib/dataforseo/serp.ts`](https://github.com/every-app/open-seo/blob/main/src/server/lib/dataforseo/serp.ts):

1. **Task posting**: `rankCheckTaskPost` submits up to 100 task-pairs to the queue, incurring the queued cost immediately
2. **Polling**: The workflow polls for completion for approximately 15 minutes
3. **Live fallback**: Any pending, failed, or rejected tasks trigger live execution via the logic in `RankCheckWorkflow`, adding a fraction of a cent to the already-paid queued cost
4. **Cost aggregation**: Final charges are summed from the `billing` envelope in DataForSEO responses (lines 240-250 in [`serp.ts`](https://github.com/every-app/open-seo/blob/main/serp.ts))

Because the queued post cost is prepaid, fallback live calls add negligible expense while ensuring 100% result delivery.

## Practical Cost Comparison

For a single keyword tracked on both desktop and mobile (2 devices) with first-page results:

| Scenario | Cost per Keyword | Relative Cost |
|----------|------------------|---------------|
| **Manual check (live)** | ~$0.004 | 100% |
| **Scheduled check (queued)** | ~$0.0012 | ~30% |
| **Live fallback** | Base + ~$0.0001 | Negligible addition |

## Implementation Examples

### Estimating Live Check Costs

```typescript
import { estimateRankCheckCredits } from "@/shared/rank-tracking";

const keywordCount = 150;
const devices = "both" as const; // desktop + mobile
const serpDepth = 20; // 2 pages (10 results per page)
const method = "live";

const { costUsd, costCredits } = estimateRankCheckCredits(
  keywordCount,
  devices,
  serpDepth,
  method,
);

console.log(`Live check: $${costUsd.toFixed(4)} → ${costCredits} credits`);

```

*Result:* `Live check: $0.0540 → 540 credits`

### Estimating Queued Check Costs

```typescript
import { estimateRankCheckCredits } from "@/shared/rank-tracking";

const method = "queued"; // scheduled runs use this
const { costUsd, costCredits } = estimateRankCheckCredits(
  keywordCount,
  devices,
  serpDepth,
  method,
);

console.log(`Queued check: $${costUsd.toFixed(4)} → ${costCredits} credits`);

```

*Result:* `Queued check: $0.0162 → 162 credits`

### Triggering Workflows

```typescript
import { startRankCheck } from "@/server/workflows/RankCheckWorkflow";

// Manual trigger (live)
await startRankCheck({
  projectId,
  configId,
  devices: "both",
  serpDepth: 20,
  trigger: "manual", // forces live
});

// Scheduled trigger (queued)
await startRankCheck({
  projectId,
  configId,
  devices: "both",
  serpDepth: 20,
  trigger: "scheduled", // uses queued pricing
});

```

## Summary

- **Queued checks cost 70% less** than live checks ($0.0006 vs $0.002 per first page in [`src/shared/rank-tracking.ts`](https://github.com/every-app/open-seo/blob/main/src/shared/rank-tracking.ts))
- **Scheduled workflows** automatically use queued pricing to minimize costs
- **Manual checks** force live methods for instant results at premium rates  
- **Live fallbacks** add negligible cost to queued checks while guaranteeing completion via `RankCheckWorkflow`
- Cost estimation relies on `estimateRankCheckCredits`, which factors keyword count, device count, and SERP depth

## Frequently Asked Questions

### Why is queued rank checking cheaper than live checking?

Queued checking leverages DataForSEO's standard task queue for batch processing, allowing the provider to optimize resource allocation across many requests. Live checking requires immediate computation and dedicated API resources, resulting in approximately 3.3x higher pricing per request as defined in the `costPerSerpAtDepth()` logic.

### What happens if a queued rank check fails?

If a queued task fails or times out during the ~15 minute polling window in `RankCheckWorkflow`, the system automatically triggers a live fallback. You pay the initial queued rate plus a fractional live charge (typically fractions of a cent), ensuring you receive results without manual intervention or missing data.

### How does OpenSEO calculate credit costs for rank checking?

The `estimateRankCheckCredits` function in [`src/shared/rank-tracking.ts`](https://github.com/every-app/open-seo/blob/main/src/shared/rank-tracking.ts) multiplies keyword count by device count (desktop/mobile), then applies the per-request rate for your chosen method. It adds SEO data markup and rounds according to billing rules, returning both USD and internal credit values derived from `AUTUMN_SEO_DATA_CREDITS_PER_USD`.

### Can I force live checking for scheduled runs?

No. The `RankCheckWorkflow` explicitly forces the `"live"` method only when `trigger: "manual"` is specified. Scheduled runs always use queued pricing to optimize costs, though they may incur small live fallback charges for incomplete tasks that require immediate resolution.