10 ਮਿੰਟਾਂ ਵਿੱਚ ਆਪਣੇ MCP ਸਰਵਰ ਨੂੰ ਮੋਨੇਟਾਈਜ਼ ਕਰੋ।
AI ਏਜੰਟਾਂ ਨੂੰ ਤੁਹਾਡੇ MCP ਸਰਵਰ ਨੂੰ ਪ੍ਰਤੀ ਕਾਲ, USDC ਵਿੱਚ, ਦਸਤਖਤ ਕੀਤੇ ਵੈੱਬਹੂਕ ਅਤੇ ਆਡੀਟ ਲਾਗਾਂ ਨਾਲ ਭੁਗਤਾਨ ਕਰਨ ਦਿਓ। x402-ਸੰਬੰਧਿਤ। ਡ੍ਰਾਪ-ਇਨ ਮਿਡਲਵੇਅਰ।
ਤੁਸੀਂ ਇੱਕ MCP ਸਰਵਰ ਬਣਾਇਆ। ਹਜ਼ਾਰਾਂ ਗਾਹਕ ਇਸਨੂੰ ਮੁਫ਼ਤ ਵਰਤ ਰਹੇ ਹਨ।
ਤੁਸੀਂ ਆਪਣਾ MCP ਸਰਵਰ ਭੇਜਿਆ ਕਿਉਂਕਿ Claude Desktop, Cursor, ਅਤੇ Cline ਗਾਹਕਾਂ ਨੂੰ ਇਸ ਸਮਰੱਥਾ ਦੀ ਲੋੜ ਸੀ। ਸ਼ਬਦ ਫੈਲ ਗਿਆ। ਤੁਸੀਂ ਹੁਣ AI ਏਜੰਟਾਂ ਤੋਂ ਹਰ ਰੋਜ਼ ਹਜ਼ਾਰਾਂ ਭੁਗਤਾਨ ਕੀਤੇ ਟੂਲ ਦੀਆਂ ਆਵਾਜ਼ਾਂ ਦੀ ਸੇਵਾ ਕਰ ਰਹੇ ਹੋ ਜੋ ਤੁਸੀਂ ਕਦੇ ਨਹੀਂ ਮਿਲੇ। ਤੁਹਾਡਾ ਇਗ੍ਰੈੱਸ ਬਿੱਲ ਵਾਸਤਵਿਕ ਹੈ। ਤੁਹਾਡਾ ਅਧਾਰਭੂਤ ਸੇਵਾ ਲਈ API ਕੁੰਜੀ ਵਾਸਤਵਿਕ ਹੈ। ਤੁਹਾਡਾ ਰੱਖ-ਰਖਾਅ ਦਾ ਸਮਾਂ ਵਾਸਤਵਿਕ ਹੈ। ਆਮਦਨ ਜ਼ੀਰੋ ਹੈ।
ਤੁਹਾਡੇ ਕੋਲ ਤਿੰਨ ਵਿਕਲਪ ਹਨ। ਇਸਨੂੰ ਮੁਫ਼ਤ ਰੱਖੋ ਅਤੇ ਢਾਂਚੇ 'ਤੇ ਪੈਸਾ ਬਰਬਾਦ ਕਰੋ। ਇਸਨੂੰ ਮੈਨੂਅਲ API ਕੁੰਜੀਆਂ ਦੇ ਪਿੱਛੇ ਰੱਖੋ (ਅਤੇ ਸਾਈਨਅਪ ਫਾਰਮਾਂ ਦੇ ਰੁਕਾਵਟ ਦੇ ਕਾਰਨ 95% ਏਜੰਟ ਟ੍ਰੈਫਿਕ ਨੂੰ ਗੁਆਓ)। ਜਾਂ ਇੱਕ ਭੁਗਤਾਨ ਪਰਤ ਜੋ AI ਏਜੰਟ ਵਾਸਤਵਿਕ ਤੌਰ 'ਤੇ ਪੂਰਾ ਕਰ ਸਕਦੇ ਹਨ ਜੋ 402 Payment Required + USDC ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਸ਼ਾਮਲ ਕਰੋ।
Blockchain0x ਵਿਕਲਪ ਤਿੰਨ ਹੈ। ਤੁਹਾਡਾ MCP ਸਰਵਰ ਸਾਡੇ API ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਇੱਕ AI ਗਾਹਕ ਇੱਕ ਭੁਗਤਾਨ ਕੀਤੀ ਟੂਲ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਤਾਂ ਜਵਾਬ 402 ਹੁੰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ਹੋਸਟ ਕੀਤਾ ਗਿਆ ਭੁਗਤਾਨ URL ਹੁੰਦਾ ਹੈ। ਗਾਹਕ (ਜਾਂ ਇਸਦਾ ਮਨੁੱਖੀ ਨਿਗਰਾਨ) USDC ਵਿੱਚ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ। ਤੁਹਾਡਾ ਵੈਬਹੂਕ ਫਾਇਰ ਹੁੰਦਾ ਹੈ। ਉਸ ਗਾਹਕ ਤੋਂ ਅਗਲੀ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ। ਪੂਰੀ ਸ਼ਕਲ ਨੂੰ x402 ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਉਸ ਪੈਟਰਨ ਲਈ Coinbase ਦੁਆਰਾ ਪ੍ਰਕਾਸ਼ਿਤ ਪ੍ਰੋਟੋਕੋਲ ਹੈ।
ਕਿਵੇਂ 402 ਭੁਗਤਾਨ ਦੀ ਲੋੜ ਇੱਕ ਪ੍ਰੋਗਰਾਮੈਟਿਕ ਚੈਕਆਉਟ ਬਣਦਾ ਹੈ।
HTTP status code 402 spec ਲਿਖੇ ਜਾਣ ਤੋਂ ਹੀ ਮੌਜੂਦ ਹੈ ਪਰ ਇਸਦੀ ਕਦੇ ਕੋਈ standard implementation ਨਹੀਂ ਸੀ। Coinbase ਦਾ x402 protocol ਆਖ਼ਿਰਕਾਰ ਇਸਨੂੰ ਇੱਕ implementation ਦਿੰਦਾ ਹੈ। Shape ਸੌਖੀ ਹੈ: ਤੁਹਾਡਾ tool 402 challenge return ਕਰਦਾ ਹੈ (ਇੱਕ structured JSON body ਜੋ ਦੱਸਦਾ ਹੈ ਕਿਵੇਂ pay ਕਰਨਾ ਹੈ); client pay ਕਰਦਾ ਹੈ ਅਤੇ retry ਕਰਦਾ ਹੈ; call success ਹੋ ਜਾਂਦੀ ਹੈ। @blockchain0x/mcp ਦਾ requirePayment ਇਹ challenge body ਤੁਹਾਡੇ ਲਈ ਬਣਾਉਂਦਾ ਹੈ।
{
"error": "payment_required",
"amountUsdc": "0.02",
"payTo": "0xYourMcpAgentAddress",
"hostedUrl": "https://pay.blockchain0x.com/checkout/docs-search",
"network": "mainnet",
"description": "docs search"
}ਚਾਰ ਰਾਜ
- ਭੁਗਤਾਨ ਨਾ ਕੀਤਾ ਗਿਆ ਕਾਲ: AI ਗਾਹਕ ਇੱਕ ਭੁਗਤਾਨ ਕੀਤੇ ਟੂਲ ਨੂੰ ਬੁਲਾਉਂਦਾ ਹੈ. ਤੁਹਾਡਾ ਹੈਂਡਲਰ ਆਪਣੇ ਭੁਗਤਾਨ-ਰਾਜ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ ਕਿ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲਾ ਭੁਗਤਾਨ ਕੀਤਾ ਹੋਇਆ ਨਹੀਂ ਹੈ, ਅਤੇ requirePayment ਤੋਂ 402 ਚੁਣੌਤੀ ਦੇ ਸਰੀਰ ਨੂੰ ਟੂਲ ਦੀ ਗਲਤੀ ਵਜੋਂ ਵਾਪਸ ਕਰਦਾ ਹੈ.
- ਭੁਗਤਾਨ: ਗਾਹਕ ਹੋਸਟ ਕੀਤੇ ਗਏ URL ਦਾ ਪਾਲਣ ਕਰਦਾ ਹੈ ਹੋਸਟ ਕੀਤੇ ਗਏ ਚੈਕਆਉਟ 'ਤੇ ਅਤੇ ਬੇਸ 'ਤੇ USDC ਦਾ ਹਵਾਲਾ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਜਾਂ ਤਾਂ x402-ਜਾਣੂ ਵਾਲਿਟ ਦੁਆਰਾ ਪ੍ਰੋਗਰਾਮੈਟਿਕ ਤੌਰ 'ਤੇ ਜਾਂ QR ਕੋਡ ਦੁਆਰਾ ਹੱਥੋਂ).
- Webhook: Blockchain0x ਭੁਗਤਾਨ.received ਨੂੰ ਤੁਹਾਡੇ ਐਂਡਪੋਇੰਟ 'ਤੇ ਚੇਨ ਦੀ ਪੁਸ਼ਟੀ ਦੇ ਕੁਝ ਸਕਿੰਟਾਂ ਦੇ ਅੰਦਰ ਭੇਜਦਾ ਹੈ. ਤੁਸੀਂ ਇਸਨੂੰ webhooks.verify ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕਰਦੇ ਹੋ ਅਤੇ ਆਪਣੇ ਸਟੋਰ ਵਿੱਚ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤਾ ਹੋਇਆ ਦਰਜ ਕਰਦੇ ਹੋ.
- ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ: ਗਾਹਕ ਮੂਲ MCP ਟੂਲ ਕਾਲ ਨੂੰ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ. ਤੁਹਾਡਾ ਹੈਂਡਲਰ ਹੁਣ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤਾ ਹੋਇਆ ਦੇ ਤੌਰ 'ਤੇ ਦੇਖਦਾ ਹੈ, ਟੂਲ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ, ਅਤੇ ਅਸਲ ਨਤੀਜਾ ਵਾਪਸ ਕਰਦਾ ਹੈ.
ਹਰ ਭੁਗਤਾਨ ਤੁਹਾਡੇ Blockchain0x ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਦਰਜ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹਰ payment.received ਵੈਬਹੂਕ ਤੁਹਾਡੇ ਆਪਣੇ ਲੌਗ ਵਿੱਚ ਆਉਂਦੀ ਹੈ। ਕਿਉਂਕਿ ਤੁਸੀਂ ਭੁਗਤਾਨ-ਸਥਿਤੀ ਅਤੇ ਵੈਬਹੂਕ ਹੈਂਡਲਰ ਦੇ ਮਾਲਕ ਹੋ, ਪ੍ਰਤੀ-ਟੂਲ ਅਤੇ ਪ੍ਰਤੀ-ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਰੇਵਨਿਊ ਵਿਸ਼ਲੇਸ਼ਣ ਉਹ ਡੇਟਾ ਹਨ ਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਸਟੋਰ ਕਰਦੇ ਹੋ।
ਇੱਕ ਪੂਰਾ ਕੰਮ ਕਰਨ ਵਾਲਾ ਉਦਾਹਰਨ.
requirePayment @blockchain0x/mcp ਤੋਂ 402 ਚੁਣੌਤੀ ਬਣਾਉਂਦਾ ਹੈ; webhooks.verify @blockchain0x/node ਤੋਂ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ। ਤੁਹਾਡੇ ਕੋਲ ਦੋ ਛੋਟੇ ਟੁਕੜੇ ਹਨ: ਸੰਦ ਦੇ ਅੰਦਰ ਭੁਗਤਾਨ-ਰਾਜ ਦੀ ਜਾਂਚ, ਅਤੇ webhook ਹੈਂਡਲਰ ਜੋ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤਾ ਹੋਇਆ ਦਰਸਾਉਂਦਾ ਹੈ। ਹੇਠਾਂ ਇੱਕ ਪੂਰਾ MCP ਸਰਵਰ ਹੈ ਜੋ ਇੱਕ ਭੁਗਤਾਨ ਕੀਤੇ ਸੰਦ ਅਤੇ ਇਸਦਾ webhook ਐਂਡਪੋਇੰਟ ਪ੍ਰਗਟ ਕਰਦਾ ਹੈ।
import express from "express";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { requirePayment } from "@blockchain0x/mcp";
import { webhooks } from "@blockchain0x/node";
const server = new McpServer({ name: "docs-search", version: "1.0.0" });
// You decide who counts as paid. Back this with Redis/Postgres in production.
const paid = new Set<string>();
server.tool(
"search_docs",
"Semantic search across our docs",
{ query: { type: "string" }, payer: { type: "string" } },
async ({ query, payer }) => {
if (!paid.has(`search_docs:${payer}`)) {
// Not paid yet: build an x402-compatible 402 challenge and return its
// body as a tool error. requirePayment is a challenge builder - it does
// not gate the call for you; this check is yours.
const { body } = requirePayment({
amountUsdc: "0.02",
payTo: "0xYourMcpAgentAddress",
hostedUrl: "https://pay.blockchain0x.com/checkout/docs-search",
description: "docs search",
});
return { content: [{ type: "text", text: JSON.stringify(body) }], isError: true };
}
const results = await runVectorSearch(query);
return { content: [{ type: "text", text: JSON.stringify(results) }] };
},
);
// Your webhook endpoint marks a payer as paid once the checkout settles.
const app = express();
app.post("/webhooks/blockchain0x", express.raw({ type: "*/*" }), (req, res) => {
const r = webhooks.verify({ headers: req.headers, rawBody: req.body, secret: process.env.BLOCKCHAIN0X_WEBHOOK_SECRET! });
if (!r.ok) return res.status(400).json({ code: r.code });
if (r.eventType === "payment.received") {
// Resolve (tool, payer) from the reference you encoded in hostedUrl, then:
paid.add("search_docs:0xPayer");
}
res.json({ received: true });
});ਸੈਟਅਪ ਕਦਮ
- 1ਆਪਣੇ MCP ਸਰਵਰ ਲਈ Blockchain0x ਏਜੰਟ ਵਾਲਿਟ ਬਣਾਓ, ਇੱਕ ਯੋਜਨਾ 'ਤੇ ਜਿਸ ਵਿੱਚ API ਅਤੇ webhook ਪਹੁੰਚ ਸ਼ਾਮਲ ਹੈ. ਉਸ ਵਾਲਿਟ ਪਤੇ ਨੂੰ ਨੋਟ ਕਰੋ ਜਿਸਨੂੰ ਤੁਸੀਂ payTo ਵਜੋਂ ਵਰਤੋਂਗੇ.
- 2ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰੋ:
npm install @blockchain0x/mcp @blockchain0x/node - 3Environment variables ਸੈੱਟ ਕਰੋ: BLOCKCHAIN0X_API_KEY (MCP ਸਰਵਰ ਇਸਨੂੰ Authorization: Bearer ਵਜੋਂ ਭੇਜਦਾ ਹੈ) ਅਤੇ BLOCKCHAIN0X_WEBHOOK_SECRET (ਡੈਸ਼ਬੋਰਡ ਦਾ signing secret ਜਿਸ ਨਾਲ webhooks.verify ਮਿਲਾਣ ਕਰਦਾ ਹੈ).
- 4ਆਪਣੇ ਭੁਗਤਾਨ ਕੀਤੇ ਟੂਲਾਂ ਨੂੰ ਗੇਟ ਕਰੋ ਆਪਣੇ ਭੁਗਤਾਨ-ਰਾਜ ਦੀ ਜਾਂਚ ਕਰਕੇ ਅਤੇ ਜਦੋਂ ਕਾਲ ਕਰਨ ਵਾਲਾ ਭੁਗਤਾਨ ਨਹੀਂ ਕਰਦਾ ਤਾਂ requirePayment ਚੁਣੌਤੀ ਦੇ ਸਰੀਰ ਨੂੰ ਵਾਪਸ ਕਰਕੇ. ਮੁਫਤ ਟੂਲਾਂ ਨੂੰ ਅਗੇਟ ਛੱਡੋ.
- 5Webhook ਐਂਡਪੋਇੰਟ ਨੂੰ ਸੰਰਚਨਾ ਕਰੋ Blockchain0x ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ (ਉਦਾਹਰਨ ਲਈ /webhooks/blockchain0x), ਫਿਰ ਹਰ ਡਿਲਿਵਰੀ ਨੂੰ webhooks.verify ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕਰੋ ਅਤੇ ਭੁਗਤਾਨ.received 'ਤੇ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤਾ ਗਿਆ ਦੇ ਤੌਰ 'ਤੇ ਚਿੰਨਿਤ ਕਰੋ.
- 6ਤਾਇਨਾਤ ਕਰੋ। ਪਹਿਲਾ AI ਕਲਾਇੰਟ ਜੋ ਤੁਹਾਡੇ ਭੁਗਤਾਨ ਕੀਤੇ ਟੂਲ ਨੂੰ ਹਿੱਟ ਕਰਦਾ ਹੈ, 402 ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਅਗਲੀ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ। ਤੁਸੀਂ 10 ਸਕਿੰਟਾਂ ਦੇ ਅੰਦਰ ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਭੁਗਤਾਨ ਦੇਖਦੇ ਹੋ।
ਤੁਸੀਂ npx @blockchain0x/mcp (stdio) ਨਾਲ Blockchain0x MCP ਸਰਵਰ ਨੂੰ ਆਪ ਵੀ ਚਲਾ ਸਕਦੇ ਹੋ ਜਾਂ mcp.blockchain0x.com 'ਤੇ ਹੋਸਟ ਕੀਤਾ ਗਿਆ Streamable HTTP ਕੰਟੇਨਰ। ਪੂਰੀ ਸੈਟਅਪ, ਜਿਸ ਵਿੱਚ webhook ਪੇਲੋਡ ਸ਼ੇਪ ਸ਼ਾਮਲ ਹਨ, ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਹੈ।
ਤੁਹਾਡੇ handler ਵਿੱਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਫੈਸਲਾ।
ਕਿਉਂਕਿ ਤੁਸੀਂ ਭੁਗਤਾਨ-ਰਾਜ ਨੂੰ ਮਾਲਕ ਹੋ, ਤੁਸੀਂ ਇਹ ਵੀ ਫੈਸਲਾ ਕਰਦੇ ਹੋ ਕਿ ਭੁਗਤਾਨ ਕਿੰਨਾ ਸਮਾਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਇੱਕ ਗਾਹਕ ਇੱਕ ਟੂਲ ਲਈ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ, ਤਾਂ ਉਨ੍ਹਾਂ ਨੂੰ ਕੁਝ ਸਮੇਂ ਦੀ ਖਿੜਕੀ ਲਈ ਭੁਗਤਾਨ ਕੀਤਾ ਗਿਆ ਮਾਰਕ ਕੀਤਾ ਜਾਵੇ, ਅਤੇ ਉਸ ਖਿੜਕੀ ਦੇ ਅੰਦਰ ਨਵੇਂ ਭੁਗਤਾਨ ਦੇ ਬਿਨਾਂ ਕਾਲਾਂ ਨੂੰ ਆਉਣ ਦਿਓ। ਖਿੜਕੀ ਨੂੰ ਬਹੁਤ ਛੋਟਾ ਸੈੱਟ ਕਰੋ ਅਤੇ ਤੁਸੀਂ ਹਰ ਕਾਲ 'ਤੇ ਗਾਹਕਾਂ ਨੂੰ ਭੁਗਤਾਨ ਦੇ ਰੋੜੇ ਨਾਲ ਸਜ਼ਾ ਦਿੰਦੇ ਹੋ; ਇਸਨੂੰ ਬਹੁਤ ਲੰਬਾ ਸੈੱਟ ਕਰੋ ਅਤੇ ਤੁਸੀਂ ਇੱਕ ਸਸਤੇ ਭੁਗਤਾਨ ਦੇ ਬਾਅਦ ਮਹਿੰਗੇ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਮੁਫ਼ਤ ਕਰ ਦਿੰਦੇ ਹੋ। ਤੁਹਾਡੇ Redis/Postgres ਕੁੰਜੀ 'ਤੇ ਇੱਕ TTL ਇਸਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਸਧਾਰਨ ਤਰੀਕਾ ਹੈ।
ਅਸੀਂ ਸਿਫਾਰਸ਼ ਕਰਦੇ windows
| ਟੂਲ ਕਿਸਮ | ਖਿੜਕੀ | ਕਿਉਂ |
|---|---|---|
| ਸਸਤਾ ਲੁੱਕਅਪ ($0.01-$0.05) | 60 ਸਕਿੰਟ | ਕਿਸੇ ਵੀ ਸੈਸ਼ਨ ਨੂੰ ਦਿੰਦੇ ਬਿਨਾਂ ਕੁਦਰਤੀ ਦੁਹਰਾਵਾਂ ਅਤੇ ਫਾਲੋ-ਅਪ ਕਾਲਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। |
| ਮੱਧਮ ਕੀਮਤ ਦੀ ਅਨੁਮਾਨ ($0.10-$1) | 30 ਸਕਿੰਟ | ਕਾਲ ਪ੍ਰਤੀ ਭੁਗਤਾਨ ਸਹੀ ਆਕਾਰ ਹੈ; ਛੋਟੀ ਕੈਸ਼ ਅਸਥਾਈ ਗਲਤੀਆਂ 'ਤੇ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਦੀ ਹੈ। |
| ਮਹਿੰਗਾ ਲੰਬਾ-ਸੰਦਰਭ ($1-$10) | 0 ਸਕਿੰਟ (ਕੋਈ ਕੈਸ਼ ਨਹੀਂ) | ਹਰ ਕਾਲ ਆਪਣਾ ਭੁਗਤਾਨ ਕੀਤਾ ਗਿਆ ਘਟਨਾ ਹੈ; ਕੋਈ ਕੈਸ਼ਿੰਗ ਨਹੀਂ। |
| ਸਬਸਕ੍ਰਿਪਸ਼ਨ-ਸ਼ੈਲੀ ਦੇ ਟੂਲ | 24 ਘੰਟੇ | ਦਰਵਾਜੇ ਦੇ ਅੰਦਰ ਅਸੀਮਿਤ ਕਾਲਾਂ ਲਈ ਦਿਨ ਵਿੱਚ ਇੱਕ ਵਾਰੀ ਭੁਗਤਾਨ ਕਰੋ। ਘੱਟ ਰੁਕਾਵਟ 'ਤੇ ਪ੍ਰਤੀ ਗਾਹਕ ਵਧੀਕ ਆਮਦਨੀ। |
ਤੁਹਾਡੇ ਭੁਗਤਾਨ-ਰਾਜ ਨੂੰ (ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਵੈਲਟ, ਟੂਲ) ਜੋੜੇ ਦੇ ਅਨੁਸਾਰ ਕੁੰਜੀ ਕਰੋ, ਜਿਸ ਤਰ੍ਹਾਂ ਉਦਾਹਰਨ search_docs:0xPayer ਨਾਲ ਕਰਦੀ ਹੈ। ਦੋ ਵੱਖਰੇ ਕਲਾਇੰਟ ਇੱਕੋ ਟੂਲ ਨੂੰ ਹਿੱਟ ਕਰਦੇ ਹਨ, ਹਰ ਇੱਕ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ। ਇੱਕੋ ਕਲਾਇੰਟ ਦੋ ਵੱਖਰੇ ਟੂਲਾਂ ਨੂੰ ਹਿੱਟ ਕਰਦਾ ਹੈ, ਦੋ ਵੱਖਰੇ ਭੁਗਤਾਨ ਦੀ ਲੋੜ ਹੈ। ਜੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਸਕੋਪ ਕਰ ਸਕਦੇ ਹੋ (ਸਭ ਟੂਲਾਂ ਵਿੱਚ ਪ੍ਰਤੀ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ); ਪ੍ਰਤੀ-ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਪ੍ਰਤੀ-ਟੂਲ ਦੀ ਵਿਸਥਾਰਤਾ ਹੀ ਕੀਮਤ ਨੂੰ ਨਿਆਂਸੰਗਤ ਬਣਾਉਂਦੀ ਹੈ।
ਚਾਰ ਕੀਮਤਾਂ ਦੇ ਆਕਾਰ ਜੋ MCP ਸਰਵਰਾਂ ਲਈ ਕੰਮ ਕਰਦੇ ਹਨ।
ਕੀਮਤ ਤੁਹਾਡਾ ਫੈਸਲਾ ਹੈ - ਤੁਸੀਂ ਮਿਡਲਵੇਅਰ ਵਿੱਚ ਪ੍ਰਤੀ ਟੂਲ ਰਕਮ ਸੈੱਟ ਕਰਦੇ ਹੋ। ਹੇਠਾਂ ਚਾਰ ਪੈਟਰਨ ਹਨ ਜੋ ਅਸੀਂ ਸਭ ਤੋਂ ਵੱਧ ਦੇਖਦੇ ਹਾਂ ਅਤੇ ਜੋ ਟੂਲ ਸ਼ੇਪ ਉਹ ਫਿੱਟ ਕਰਦੇ ਹਨ।
ਪ੍ਰਤੀ ਕਾਲ ਮਾਈਕ੍ਰੋ-ਕੀਮਤ
$0.01 - $0.05 ਪ੍ਰਤੀ ਕਾਲਖੋਜ, ਲੁਕਾਅ, ਵਰਗੀਕਰਨ, ਫਾਰਮੈਟ ਬਦਲਾਅ - ਉੱਚ ਮਾਤਰਾ ਵਾਲੀਆਂ ਸਸਤੀ ਕਾਰਵਾਈਆਂ।
ਗਾਹਕਾਂ ਲਈ ਸਭ ਤੋਂ ਘੱਟ ਰੁਕਾਵਟ; ਖਰਚ ਨੂੰ ਵਰਤੋਂ ਦੇ ਨਾਲ ਬਿਲਕੁਲ ਮਿਲਾਉਂਦਾ ਹੈ.
ਸਭ ਤੋਂ ਉੱਚਾ ਲੈਣ-ਦੇਣ ਦਾ ਓਵਰਹੈੱਡ; ਸਿਰਫ ਉੱਚ ਕਾਲ ਵਾਲੀ ਮਾਤਰਾ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ।
ਪ੍ਰਤੀ ਕਾਲ ਮੱਧ ਕੀਮਤ
$0.10 - $1.00 ਪ੍ਰਤੀ ਕਾਲLLM inference, generation, content production, ਕੁਝ ਵੀ ਜਿੱਥੇ ਹਰ ਕਾਲ ਵਾਸਤਵਿਕ ਕੰਮ ਕਰਦੀ ਹੈ।
ਸੰਤੁਲਿਤ - ਹਰ ਕਾਲ ਲਈ ਸਪਸ਼ਟ ਮੁੱਲ, ਸੰਭਾਲਣ ਯੋਗ ਲੈਣ-ਦੇਣ ਦੀ ਗਿਣਤੀ।
ਹਰ ਕਾਲ 'ਤੇ ਉੱਚ ਫ੍ਰਿਕਸ਼ਨ; ਗਾਹਕ ਕਈ ਵਾਰੀ ਇਸ ਕੀਮਤ ਦੇ ਬਿੰਦੂ 'ਤੇ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹਨ।
ਪ੍ਰਤੀ ਕਾਲ ਉੱਚ ਕੀਮਤ
$1 - $10 ਪ੍ਰਤੀ ਕਾਲਲੰਬੇ ਸੰਦਰਭ ਦੀ ਪੈਦਾਵਾਰ, ਦਸਤਾਵੇਜ਼ ਪ੍ਰਕਿਰਿਆ, ਬਹੁ-ਕਦਮ ਸੰਗਠਨ, ਮਹਿੰਗੇ ਤੀਜੇ ਪੱਖ ਦੇ API ਲਪੇਟਣਾ.
ਹਰ ਕਾਲ ਲਈ ਮਾਰਜਿਨ ਅਰਥਪੂਰਨ ਹੈ; ਅਸਫਲ ਭੁਗਤਾਨ ਸਹਿਣਯੋਗ ਨੁਕਸਾਨ ਹਨ.
ਗਾਹਕ ਇਸ ਕੀਮਤ 'ਤੇ ਮਜ਼ਬੂਤੀ ਨਾਲ ਮੋਲ-ਤੋਲ ਕਰਦੇ ਹਨ; ਵਾਪਸੀ ਦੀਆਂ ਬੇਨਤੀਆਂ ਦੀ ਉਮੀਦ ਕਰੋ।
ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਵਿੰਡੋ
$5 - $50 ਪ੍ਰਤੀ 24 ਘੰਟੇ ਦੀ ਵਿੰਡੋ (ਜਾਂ $X ਪ੍ਰਤੀ ਮਹੀਨਾ)ਗਾਹਕ ਜੋ ਇੱਕ ਸੈਸ਼ਨ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਕਾਲਾਂ ਕਰਦੇ ਹਨ ਅਤੇ ਜੋ ਪ੍ਰਤੀ-ਕਾਲ ਭੁਗਤਾਨ ਦੇ ਰੁਕਾਵਟ ਨੂੰ ਸਹਿਣ ਨਹੀਂ ਕਰਦੇ।
ਹਰ ਗਾਹਕ ਲਈ ਉੱਚ ਆਮਦਨ; ਪ੍ਰਤੀ ਕਾਲ ਘੱਟ ਓਵਰਹੈੱਡ।
ਘੱਟ ਪਤਾ ਲਗਾਉਣਯੋਗਤਾ; ਗਾਹਕਾਂ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਵਚਨਬੱਧ ਹੋਣਾ ਪੈਂਦਾ ਹੈ। ਅਕਸਰ ਹਾਈਬ੍ਰਿਡ ਕੀਮਤ ਲਈ ਪ੍ਰਤੀ-ਕਾਲ ਦੇ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ.
ਬਹੁਤ ਸਾਰੇ ਓਪਰੇਟਰ ਪੈਟਰਨ ਨੂੰ ਮਿਲਾਉਂਦੇ ਹਨ: ਪ੍ਰਤੀ-ਕਾਲ ਮਾਈਕ੍ਰੋ-ਮੁੱਲ 'ਤੇ ਸਸਤੇ ਟੂਲ, ਪ੍ਰਤੀ-ਕਾਲ ਉੱਚ-ਮੁੱਲ 'ਤੇ ਮਹਿੰਗੇ ਟੂਲ, ਅਤੇ ਭਾਰੀ ਉਪਭੋਗਤਾਵਾਂ ਲਈ 24-ਘੰਟੇ ਦੀ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਵਿੰਡੋ। ਕੁਝ ਵੀ ਤੁਹਾਨੂੰ ਇੱਕੋ ਹੀ MCP ਸਰਵਰ 'ਤੇ ਤਿੰਨੋਂ ਚਲਾਉਣ ਤੋਂ ਨਹੀਂ ਰੋਕਦਾ; ਹਰ ਟੂਲ ਆਪਣੇ ਆਪ ਦਾ amountUsdc requirePayment ਵਿੱਚ ਅਤੇ ਆਪਣੇ ਆਪ ਦਾ ਭੁਗਤਾਨ-ਵਿੰਡੋ ਤੁਹਾਡੇ ਹੈਂਡਲਰ ਵਿੱਚ ਸੈੱਟ ਕਰਦਾ ਹੈ।
ਪ੍ਰੋ ਲਗਭਗ ਹਰ MCP ਸਰਵਰ ਲਈ ਸਹੀ ਯੋਜਨਾ ਹੈ।
MCP ਸਰਵਰ ਓਪਰੇਟਰ ਲਗਭਗ ਹਮੇਸ਼ਾਂ Pro 'ਤੇ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ ਕਿਉਂਕਿ API ਲਿਖਣ ਦੀ ਪਹੁੰਚ ਅਤੇ webhook ਪਹਿਲੇ ਦਿਨ ਤੋਂ ਲਾਜ਼ਮੀ ਹਨ: ਮੁਫਤ ਪੜ੍ਹਨ ਲਈ ਹੀ ਹੈ, ਅਤੇ ਇੱਕ ਭੁਗਤਾਨ ਕੀਤੀ ਟੂਲ ਨੂੰ payment.received webhook ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਸਹੀ ਪ੍ਰਤੀ-ਏਜੰਟ ਲਾਗਤ ਅਤੇ ਜਿੱਥੇ ਲੈਣ-ਦੇਣ-ਫੀ ਟੀਅਰ ਬੈਠਦੇ ਹਨ, ਇਸ ਲਈ ਕੀਮਤ ਪੰਨਾ ਵੇਖੋ; ਛੋਟਾ ਸੰਸਕਰਨ ਇਹ ਹੈ ਕਿ ਕੋਈ ਵੀ ਸਰਵਰ ਜੋ ਵਾਸਤਵਿਕ ਭੁਗਤਾਨ ਵਾਲੀ ਮਾਤਰਾ ਕਰ ਰਿਹਾ ਹੈ ਉਹ ਬਹੁਤ ਹੀ ਪਾਸ ਹੈ ਜਿੱਥੇ Pro ਆਪਣੇ ਆਪ ਲਈ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ।
- Free: API ਅਤੇ dashboard ਨਾਲ experiment ਕਰਨ ਲਈ ਉਪਯੋਗੀ। production paid tools ਲਈ ਯੋਗ ਨਹੀਂ (read-only, ਕੋਈ webhooks ਨਹੀਂ)।
- Pro: live MCP servers ਲਈ default. Full API access, webhooks, exports.
- Business: ਜਦੋਂ ਤੁਹਾਨੂੰ compliance ਲਈ audit log ਦੀ ਲੋੜ ਹੋਵੇ, ਜਾਂ ਜਦੋਂ ਤੁਸੀਂ ਕਈ clients ਲਈ MCP servers ਚਲਾਉਂਦੇ ਹੋ ਅਤੇ per-agent team-seat sharing ਚਾਹੁੰਦੇ ਹੋ।