価格設定
デフォルトでは、ユーザーはWorkersの無料プランにアクセスできます。Workersの無料プランには、Workers、Pages Functions、およびWorkers KVの制限された使用が含まれています。無料プランの制限について詳しく読むことができます。
Workersの有料プランには、Workers、Pages Functions、Workers KV、およびDurable Objectsの使用が含まれ、アカウントごとに月額最低5ドルの料金がかかります。このプランには、初期の使用割当が増加し、基本プランを超える使用に対して明確な料金が設定されています。
すべての含まれる使用は月単位です。
使用モデルは、使用に対してどのように請求されるか、また、各呼び出しごとにWorkerが使用できるCPU時間の上限制限を指定する設定です。
Workersの有料プランのユーザーは、標準使用モデルにのみアクセスできます。
Workers Enterpriseアカウントは、契約で指定された使用モデルに基づいて請求されます。標準使用モデルに切り替えるには、CSMに連絡してください。一部のWorkers Enterprise顧客は、使用モデルを変更する能力を維持しています。
| リクエスト1 | 期間 | CPU時間 | |
|---|---|---|---|
| 無料 | 1日あたり100,000 | 期間に対して料金は発生しない | 各呼び出しごとに10ミリ秒のCPU時間 |
| 標準 | 月に1,000万件含まれる +追加の1百万件ごとに$0.30 | 期間に対して料金や制限は発生しない | 月に30百万CPUミリ秒が含まれる +追加の1百万CPUミリ秒ごとに$0.02 各呼び出しごとに最大30秒のCPU時間 各Cron TriggerまたはQueue Consumerの呼び出しごとに最大15分のCPU時間 |
1 あなたのWorkerへの受信リクエスト。Cloudflareは、あなたのWorkerから行うサブリクエストに対して請求しません。
月に1500万件のリクエストを処理し、各リクエストごとに平均7ミリ秒（ms）のCPU時間を使用するWorkerの推定コストは以下の通りです。
| 月額コスト | 計算式 | |
|---|---|---|
| サブスクリプション | $5.00 | |
| リクエスト | $1.50 | (15,000,000リクエスト - 10,000,000含まれるリクエスト) / 1,000,000 * $0.30 |
| CPU時間 | $1.50 | ((1リクエストあたり7 msのCPU時間 * 15,000,000リクエスト) - 30,000,000含まれるCPU ms) / 1,000,000 * $0.02 |
| 合計 | $8.00 |
複数のAPIからデータを収集し、データを処理してレポートを作成するために、1時間ごとにCron Triggerで実行されるWorker。
- 月に720リクエスト
- 各リクエストごとに3分（180,000ms）のCPU時間
このシナリオでは、推定月額コストは以下のように計算されます。
| 月額コスト | 計算式 | |
|---|---|---|
| サブスクリプション | $5.00 | |
| リクエスト | $0.00 | - |
| CPU時間 | $1.99 | ((1リクエストあたり180,000 msのCPU時間 * 720リクエスト) - 30,000,000含まれるCPU ms) / 1,000,000 * $0.02 |
| 合計 | $6.99 | |
月に1億件のリクエストを処理し、各リクエストごとに平均7ミリ秒（ms）のCPU時間を使用する高トラフィックのWorkerの推定コストは以下の通りです。
| 月額コスト | 計算式 | |
|---|---|---|
| サブスクリプション | $5.00 | |
| リクエスト | $27.00 | (100,000,000リクエスト - 10,000,000含まれるリクエスト) / 1,000,000 * $0.30 |
| CPU時間 | $13.40 | ((1リクエストあたり7 msのCPU時間 * 100,000,000リクエスト) - 30,000,000含まれるCPU ms) / 1,000,000 * $0.02 |
| 合計 | $45.40 |
| リクエスト1 | 期間 | CPU時間 | |
|---|---|---|---|
| バンドル | 月に1,000万件含まれる +追加の1百万件ごとに$0.50 | 期間に対して料金は発生しない | 各呼び出しごとに50ミリ秒のCPU時間 |
| アンバウンド | 月に1百万件含まれる +追加の1百万件ごとに$0.15 | 月に400,000 GB-s含まれる +追加の1百万GB-sごとに$12.502, 3 | 各呼び出しごとに30秒のCPU時間 各Cron TriggerまたはQueue Consumerの呼び出しごとに15分のCPU時間 |
1 あなたのWorkerへの受信リクエスト。外部サービスへのサブリクエストは単位ベースで請求されませんが、Workerの期間（ウォールクロック時間）に影響を与えます。
2 Cloudflareは、ウォールタイムまたはCPU時間のいずれか高い方に基づいて期間料金を請求し、CPU時間にはWorkerに割り当てられた処理能力を考慮して8倍の倍率が適用されます。Cloudflareは、実行制限を超えるウォールタイムの期間料金を請求しません。
3 期間の請求は、実際の使用に関係なく、Workerに割り当てられた128 MBのメモリに対して請求されます。アカウントに特定のWorkerへのトラフィックが多い場合、同じ物理マシン上の同じアイソレートで複数のインスタンスが実行され、128 MBのメモリを共有することがあります。これらのWorkersは、別々のインスタンスとして請求され、各インスタンスは128 MBのメモリを持つかのように請求されます。
月に1億件のリクエストを処理するWorkerの推定コストは以下の通りです。
| 月額コスト | 計算式 | |
|---|---|---|
| Workers有料プラン | $5 | |
| リクエスト | $45 | (100,000,000リクエスト - 10,000,000含まれるリクエスト) / 1,000,000 * $0.50 |
| 合計 | $50 |
月に1億件のリクエストを処理し、各リクエストの平均期間（ウォールクロック時間）が200ミリ秒であるWorkerを考えます。これは以下のような期間（ウォールクロック時間）メトリックに変換されます：
- 各リクエストあたり0.2秒（200ミリ秒 / 1000）
- 各リクエストあたり0.025ギガバイト秒（GB-s）（0.2秒 * 128 MB / 1024 MB）
- 月に2,500,000ギガバイト秒（GB-s）（0.025 GB-s /リクエスト * 100,000,000リクエスト）
これにより、推定コストは以下の通りです。
| 月額コスト | 計算式 | |
|---|---|---|
| Workers有料プラン | $5.00 | |
| リクエスト | $14.85 | (100,000,000リクエスト - 1,000,000含まれるリクエスト) / 1,000,000 * $0.15 |
| 期間 | $26.25 | (月に2,500,000 GB-s - 400,000含まれるGB-s) / 1,000,000 * $12.50 |
| 合計 | $46.10 |
使用モデルは、個々のWorkerレベルで変更できます：
- Cloudflareダッシュボード ↗にログインし、アカウントを選択します。
- アカウントホームで、Workers & Pagesを選択します。
- 概要で、Workerを選択 > 設定 > 使用モデルを選択します。
アカウント全体のデフォルト使用モデルを変更するには：
- Cloudflareダッシュボード ↗にログインし、アカウントを選択します。
- アカウントホームで、Workers & Pagesを選択します。
- 右側のメニューで使用モデルを見つけて > 変更を選択します。
既存のWorkersは、デフォルトの使用モデルを変更しても影響を受けません。個々のWorkersの使用モデルを変更しても、アカウント全体のデフォルト使用モデルには影響しません。
Workers Logpushは、Workersの有料プランでのみ利用可能です。
| 有料プラン | |
|---|---|
| リクエスト 1 | 月に1,000万件、+追加の1百万件ごとに$0.05 |
1 Workers Logpushは、フィルタリングまたはサンプリングを適用した後に、最終的な宛先に到達するリクエストログに対して料金を請求します。
Workers KV is included in both the Free and Paid Workers plans.
| Free plan1 | Paid plan | |
|---|---|---|
| Read requests | 100,000 / day | 10 million/month, + $0.50/million |
| Write requests | 1,000 / day | 1 million/month, + $5.00/million |
| Delete requests | 1,000 / day | 1 million/month, + $5.00/million |
| List requests | 1,000 / day | 1 million/month, + $5.00/million |
| Stored data | 1 GB | 1 GB, + $0.50/ GB-month |
1 The Workers Free plan includes limited Workers KV usage. All limits reset daily at 00:00 UTC. If you exceed any one of these limits, further operations of that type will fail with an error.
Cloudflare Queues charges for the total number of operations against each of your queues during a given month.
- An operation is counted for each 64 KB of data that is written, read, or deleted.
- Messages larger than 64 KB are charged as if they were multiple messages: for example, a 65 KB message and a 127 KB message would both incur two operation charges when written, read, or deleted.
- A KB is defined as 1,000 bytes, and each message includes approximately 100 bytes of internal metadata.
- Operations are per message, not per batch. A batch of 10 messages (the default batch size), if processed, would incur 10x write, 10x read, and 10x delete operations: one for each message in the batch.
- There are no data transfer (egress) or throughput (bandwidth) charges.
| Workers Paid | |
|---|---|
| Standard operations | 1,000,000 operations/month included + $0.40/million operations |
In most cases, it takes 3 operations to deliver a message: 1 write, 1 read, and 1 delete. Therefore, you can use the following formula to estimate your monthly bill:
((Number of Messages * 3) - 1,000,000) / 1,000,000 * $0.40Additionally:
- Each retry incurs a read operation. A batch of 10 messages that is retried would incur 10 operations for each retry.
- Messages that reach the maximum retries and that are written to a Dead Letter Queue incur a write operation for each 64 KB chunk. A message that was retried 3 times (the default), fails delivery on the fourth time and is written to a Dead Letter Queue would incur five (5) read operations.
- Messages that are written to a queue, but that reach the maximum persistence duration (or “expire”) before they are read, incur only a write and delete operation per 64 KB chunk.
D1は、Workers FreeおよびWorkers Paidプランの両方で利用可能です。
| Workers Free | Workers Paid | |
|---|---|---|
| Rows read | 5 million / day | First 25 billion / month included + $0.001 / million rows |
| Rows written | 100,000 / day | First 50 million / month included + $1.00 / million rows |
| Storage (per GB stored) | 5 GB (total) | First 5 GB included + $0.75 / GB-mo |
- Rows read measure how many rows a query reads (scans), regardless of the size of each row. For example, if you have a table with 5000 rows and run a
SELECT * FROM tableas a full table scan, this would count as 5,000 rows read. A query that filters on an unindexed column may return fewer rows to your Worker, but is still required to read (scan) more rows to determine which subset to return. - Rows written measure how many rows were written to D1 database. Write operations include
INSERT,UPDATE, andDELETE. Each of these operations contribute towards rows written. A query thatINSERT10 rows into auserstable would count as 10 rows written. - DDL operations (for example,
CREATE,ALTER, andDROP) are used to define or modify the structure of a database. They may contribute to a mix of read rows and write rows. Ensure you are accurately tracking your usage through the available tools. - Row size or the number of columns in a row does not impact how rows are counted. A row that is 1 KB and a row that is 100 KB both count as one row.
- Defining indexes on your table(s) reduces the number of rows read by a query when filtering on that indexed field. For example, if the
userstable has an index on a timestamp columncreated_at, the querySELECT * FROM users WHERE created_at > ?1would only need to read a subset of the table. - Indexes will add an additional written row when writes include the indexed column, as there are two rows written: one to the table itself, and one to the index. The performance benefit of an index and reduction in rows read will, in nearly all cases, offset this additional write.
- Storage is based on gigabytes stored per month, and is based on the sum of all databases in your account. Tables and indexes both count towards storage consumed.
- Free limits reset daily at 00:00 UTC. Monthly included limits reset based on your monthly subscription renewal date, which is determined by the day you first subscribed.
- There are no data transfer (egress) or throughput (bandwidth) charges for data accessed from D1.
Durable Objects are only available on the Workers Paid plan.
| Paid plan | |
|---|---|
| Requests | 1 million, + $0.15/million Includes HTTP requests, RPC sessions1, WebSocket messages2, and alarm invocations |
| Duration3 | 400,000 GB-s, + $12.50/million GB-s4,5 |
1 Each RPC session is billed as one request to your Durable Object. Every RPC method call on a Durable Objects stub is its own RPC session and therefore a single billed request.
RPC method calls can return objects (stubs) extending RpcTarget and invoke calls on those stubs. Subsequent calls on the returned stub are part of the same RPC session and are not billed as separate requests. For example:
let durableObjectStub = OBJECT_NAMESPACE.get(id); // retrieve Durable Object stubusing foo = await durableObjectStub.bar(); // billed as a requestawait foo.baz(); // treated as part of the same RPC session created by calling bar(), not billed as a requestawait durableObjectStub.cat(); // billed as a request2 A request is needed to create a WebSocket connection. There is no charge for outgoing WebSocket messages, nor for incoming WebSocket protocol pings ↗. For compute requests billing-only, a 20:1 ratio is applied to incoming WebSocket messages to factor in smaller messages for real-time communication. For example, 100 WebSocket incoming messages would be charged as 5 requests for billing purposes. The 20:1 ratio does not affect Durable Object metrics and analytics, which reflect actual usage.
3 Application level auto-response messages handled by state.setWebSocketAutoResponse() will not incur additional wall-clock time, and so they will not be charged.
4 Duration is billed in wall-clock time as long as the Object is active, but is shared across all requests active on an Object at once. Once your Object finishes responding to all requests, it will stop incurring duration charges. Calling accept() on a WebSocket in an Object will incur duration charges for the entire time the WebSocket is connected. If you prefer, use state.acceptWebSocket() instead, which will stop incurring duration charges once all event handlers finish running.
5 Duration billing charges for the 128 MB of memory your Durable Object is allocated, regardless of actual usage. If your account creates many instances of a single Durable Object class, Durable Objects may run in the same isolate on the same physical machine and share the 128 MB of memory. These Durable Objects are still billed as if they are allocated a full 128 MB of memory.
The Durable Objects Transactional Storage API is only accessible from within Durable Objects.
Durable Objects do not have to use the Transactional Storage API, but if your code does call methods on state.storage, it will incur the following additional charges:
| Paid plan | |
|---|---|
| Read request units1,2 | 1 million, + $0.20/million |
| Write request units3 | 1 million, + $1.00/million |
| Delete requests4 | 1 million, + $1.00/million |
| Stored data5 | 1 GB, + $0.20/ GB-month |
1 A request unit is defined as 4 KB of data read or written. A request that writes or reads more than 4 KB will consume multiple units, for example, a 9 KB write will consume 3 write request units.
2 List operations are billed by read request units, based on the amount of data examined. For example, a list request that returns a combined 80 KB of keys and values will be billed 20 read request units. A list request that does not return anything is billed for 1 read request unit.
3 Each alarm write is billed as a single write request unit.
4 Delete requests are unmetered. For example, deleting a 100 KB value will be charged one delete request.
5 Durable Objects will be billed for stored data until the data is removed. Once the data is removed, the object will be cleaned up automatically by the system.
Requests that hit the Durable Objects in-memory cache or that use the multi-key versions of get()/put()/delete() methods are billed the same as if they were a normal, individual request for each key.
Vectorizeは現在、Workersの有料プランでのみ利用可能です。
| Workers Paid | Workers Free 1 | |
|---|---|---|
| Total queried vector dimensions | First 50 million queried vector dimensions / month included + $0.040 per million | 30 million queried vector dimensions / month |
| Total stored vector dimensions | First 10 million stored vector dimensions + $0.040 per million | 5 million stored vector dimensions |
1 Vectorize will be available to developers on the Workers Free plan in the future.
To calculate your potential usage, calculate the sum of your stored + queried vectors, multiply by the dimension size, and multiply by the unit price (divided by 1 million). The formula is defined as (stored vectors + queried vectors) * dimensions * ($0.040 / 1000000)
- For example, inserting 10,000 vectors of 768 dimensions each, and querying those 1,000 times per day (30,000 times per month) would be calculated as
(30000 * 768) = 23,040,000queried dimensions and(10000 * 768) = 7,680,000stored dimensions (within the included monthly allocation) - Separately, and excluding the included monthly allocation, this would be calculated as
(30,000+10,000) * 768 * ($0.040 / 1,000,000)and sum to $1.23 per month.
Service Bindingを介して、あなたのWorkerから別のWorkerへのリクエストは、追加のリクエスト料金が発生しません。これにより、追加のコストをかけずに機能を複数のWorkersに分割できます。
例えば、Worker AがService Bindingを介してWorker Bにサブリクエストを行ったり、Service Bindingを介してWorker Bが提供するRPCメソッドを呼び出した場合、これは次のように請求されます：
- 一つのリクエスト（Worker Aの初回呼び出しのため）
- Worker AとWorker Bの両方で使用されたCPU時間の合計
Workers Paidプランは、あなたが持っている他のCloudflareプラン（Free、Professional、Business）とは別です。エンタープライズ顧客の場合は、価格の詳細を確認するためにアカウントチームに連絡してください。
Workerにヒットしたリクエストのみが、あなたの制限および請求にカウントされます。Cloudflare WorkersはCloudflareキャッシュの前で実行されるため、リクエストのキャッシングでもコストが発生します。制限が適用された後の定義と動作を確認するには、Limitsを参照してください。