10 મિનિટમાં તમારા MCP સર્વરને મોનિટાઇઝ કરો.
AI એજન્ટોને તમારા MCP સર્વરને દરેક કોલ માટે, USDCમાં, સહી કરેલ વેબહૂક્સ અને ઓડિટ લોગ્સ સાથે ચૂકવવા દો. x402-સંગત. ડ્રોપ-ઇન માધ્યમ.
તમે એક MCP સર્વર બનાવ્યો. હજારો ક્લાયન્ટો તેને મફતમાં ઉપયોગ કરી રહ્યા છે.
તમે તમારો MCP સર્વર શિપ કર્યો કારણ કે ક્લોડ ડેસ્કટોપ, કર્સર, અને ક્લાઇન ક્લાયન્ટોને ક્ષમતા જોઈએ હતી. શબ્દ ફેલાયો. તમે હવે AI એજન્ટો પાસેથી દરરોજ હજારો ચૂકવેલ ટૂલ આવાહનો સેવા આપી રહ્યા છો જે તમે ક્યારેય મળ્યા નથી. તમારું ઇગ્રેસ બિલ વાસ્તવિક છે. આધારભૂત સેવા માટે તમારો API કી વાસ્તવિક છે. તમારું જાળવણી સમય વાસ્તવિક છે. આવક શૂન્ય છે.
તમારા પાસે ત્રણ વિકલ્પો છે. તેને મફત રાખો અને ઇન્ફ્રાસ્ટ્રક્ચર પર પૈસા બર્ન કરો. તેને મેન્યુઅલ API કી પાછળ ગેટ કરો (અને સાઇનઅપ ફોર્મના ઘર્ષણને કારણે એજન્ટ ટ્રાફિકનો 95% ગુમાવો). અથવા એક ચુકવણી સ્તર ઉમેરો જે AI એજન્ટો ખરેખર પૂર્ણ કરી શકે છે - જે ચોક્કસપણે 402 ચુકવણીની જરૂર + USDC માટે બનાવવામાં આવ્યું છે.
Blockchain0x વિકલ્પ ત્રણ છે. તમારો MCP સર્વર અમારા API તરફ સંકેત કરે છે. જ્યારે AI ક્લાયન્ટ ચૂકવેલ ટૂલને કૉલ કરે છે, ત્યારે પ્રતિસાદ 402 છે જેમાં હોસ્ટેડ ચુકવણી URL હોય છે. ક્લાયન્ટ (અથવા તેના માનવ દેખરેખ રાખનાર) USDC માં ચૂકવે છે. તમારો વેબહૂક ફાયર થાય છે. તે ક્લાયન્ટ તરફથી આગામી કૉલ સફળ થાય છે. સમગ્ર આકારને x402 કહેવામાં આવે છે, અને તે તે ચોક્કસ પેટર્ન માટે Coinbase દ્વારા પ્રકાશિત પ્રોટોકોલ છે.
કેવી રીતે 402 ચુકવણીની જરૂરિયાત પ્રોગ્રામેટિક ચેકઆઉટ બની જાય છે.
HTTP સ્થિતિ કોડ 402 પ્રથમ વખત લખાય તે સમયે અસ્તિત્વમાં છે પરંતુ ક્યારેય માનક અમલ ન હતું. Coinbaseનું x402 પ્રોટોકોલ અંતે તેને એક આપે છે. આ સ્વરૂપ સરળ છે: તમારું ટૂલ 402 પડકાર (ચુકવણી કેવી રીતે કરવી તે વર્ણવતું એક બંધનાત્મક JSON બોડી) પરત કરે છે; ક્લાયન્ટ ચૂકવે છે અને પુનરાવર્તિત કરે છે; કોલ સફળ થાય છે. @blockchain0x/mcpમાંથી requirePayment તમારા માટે તે પડકાર બોડી બનાવે છે.
{
"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 ને હોસ્ટેડ ચેકઆઉટ પર અનુસરે છે અને Base પર USDC ટ્રાન્સફર પૂર્ણ કરે છે (કિંવાં પ્રોગ્રામેટિક રીતે x402-જાણકાર વૉલેટ દ્વારા અથવા ક્યુઆર કોડ દ્વારા મેન્યુઅલ રીતે).
- વેબહુક: Blockchain0x ચુકવણી.received ને તમારા એન્ડપોઈન્ટ પર ચેઇન પુષ્ટિની સેકંડોમાં ફાયર કરે છે. તમે તેને webhooks.verify સાથે ચકાસો અને તમારા પોતાના સ્ટોરમાં ચૂકવનારને ચૂકવેલ તરીકે નોંધો.
- પુનરાવર્તન: ક્લાયન્ટ મૂળ MCP ટૂલ કૉલને પુનરાવર્તિત કરે છે. તમારો હેન્ડલર હવે ચૂકવનારને ચૂકવેલ તરીકે ચિહ્નિત કરે છે, ટૂલ ચલાવે છે, અને વાસ્તવિક પરિણામ આપે છે.
દરેક ચુકવણી તમારા Blockchain0x ડેશબોર્ડમાં નોંધાય છે, અને દરેક payment.received વેબહૂક તમારા પોતાના લોગમાં આવે છે. કારણ કે તમે ચૂકવેલ-રાજ્ય અને વેબહૂક હેન્ડલરના માલિક છો, પ્રતિ-ટૂલ અને પ્રતિ-પેયર આવક વિશ્લેષણ તે ડેટામાંથી ઉતરે છે જે તમે પહેલેથી જ સંગ્રહિત કરો છો.
એક સંપૂર્ણ કાર્યરત ઉદાહરણ.
@blockchain0x/mcp નું requirePayment 402 challenge બનાવે છે; @blockchain0x/node નું webhooks.verify confirmation ને verify કરે છે. વચ્ચેના બે નાના ભાગો તમારા જવાબદારીમાં છે: tool અંદર paid-state check, અને payer ને paid તરીકે mark કરતો webhook handler. નીચે એક complete MCP server છે જે એક paid tool અને તેનું webhook endpoint expose કરે છે.
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 અને વેબહુક ઍક્સેસને સમાવેશ કરે છે. નોંધો કે તમે payTo તરીકે ઉપયોગ કરવા માટે વૉલેટ સરનામું.
- 2પેકેજો ઇન્સ્ટોલ કરો:
npm install @blockchain0x/mcp @blockchain0x/node - 3પર્યાવરણ વેરિએબલ્સ સેટ કરો: BLOCKCHAIN0X_API_KEY (MCP સર્વર તેને Authorization: Bearer તરીકે મોકલે છે) અને BLOCKCHAIN0X_WEBHOOK_SECRET (ડેશબોર્ડનું signing secret, જેની સામે webhooks.verify ચકાસે છે).
- 4તમારા ચૂકવેલ સાધનોને ગેટ કરો તમારા પોતાના ચૂકવેલ-રાજ્યને ચકાસીને અને જ્યારે કૉલર ચૂકવતું નથી ત્યારે requirePayment પડકાર શરીર પાછું આપીને. મફત સાધનોને અણગેટ રાખો.
- 5વેબહુક એન્ડપોઈન્ટને કન્ફિગર કરો Blockchain0x ડેશબોર્ડમાં (ઉદાહરણ તરીકે /webhooks/blockchain0x), પછી દરેક ડિલિવરીને webhooks.verify સાથે ચકાસો અને ચુકવનારને payment.received પર ચૂકવેલ તરીકે ચિહ્નિત કરો.
- 6ડિપ્લોય કરો. પ્રથમ AI ક્લાયન્ટ જે તમારા ચૂકવેલ ટૂલને હિટ કરે છે તે 402 મેળવે છે, ચૂકવે છે, અને આગામી કોલ સફળ થાય છે. તમે 10 સેકન્ડમાં ડેશબોર્ડમાં ચુકવણી જુઓ છો.
તમે npx @blockchain0x/mcp (stdio) અથવા mcp.blockchain0x.com પર હોસ્ટેડ સ્ટ્રીમેબલ HTTP કન્ટેનર સાથે Blockchain0x MCP સર્વર પણ ચલાવી શકો છો. સંપૂર્ણ સેટઅપ, જેમાં વેબહુક પેઇલોડ આકારોનો સમાવેશ થાય છે, દસ્તાવેજોમાં છે.
તમારા હેન્ડલરમાં સૌથી મહત્વપૂર્ણ નિર્ણય.
કારણ કે તમે ચૂકવેલ રાજ્યના માલિક છો, તમે પણ નક્કી કરો છો કે ચુકવણી કેટલા સમય સુધી ગણાય છે. જ્યારે ક્લાયન્ટ એક સાધન માટે ચૂકવે છે, ત્યારે તેમને કેટલાક સમય માટે ચૂકવેલ તરીકે ચિહ્નિત રાખો, અને તે વિન્ડોમાં નવા ચુકવણી વિના કોલ્સને પસાર થવા દો. વિન્ડોને ખૂબ ટૂંકું નક્કી કરો અને તમે દરેક કોલ પર ચુકવણીના ઘર્ષણ સાથે ક્લાયન્ટને દંડિત કરો છો; તેને ખૂબ લાંબું નક્કી કરો અને તમે એક સસ્તી ચુકવણી પછી મોંઘી કામગીરી આપી રહ્યા છો. તમારા Redis/Postgres કી પર TTL અમલમાં મૂકવાનો સૌથી સરળ માર્ગ છે.
અમે જે વિન્ડોઝની ભલામણ કરીએ છીએ
| ટૂલ પ્રકાર | વિન્ડો | કેમ |
|---|---|---|
| સસ્તું લુકઅપ ($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 અનુમાન, જનરેશન, સામગ્રી ઉત્પાદન, કંઈપણ જ્યાં દરેક કૉલ વાસ્તવિક કાર્ય કરે છે.
સંતુલિત - પ્રતિ કોલ સ્પષ્ટ મૂલ્ય, વ્યવસ્થાપિત ટ્રાન્ઝેક્શન સંખ્યા.
દરેક કોલ માટે વધુ ઘર્ષણ; ગ્રાહકો ક્યારેક આ ભાવ બિંદુ પર સબ્સ્ક્રિપ્શનને પસંદ કરે છે.
પ્રતિ કોલ ઉચ્ચ-કિંમત
$1 - $10 પ્રતિ કૉલલાંબા સંદર્ભની જનરેશન, દસ્તાવેજ પ્રક્રિયા, બહુ-કદમનું ઓર્કેસ્ટ્રેશન, ખર્ચાળ ત્રીજા પક્ષના API રેપિંગ.
પ્રતિ કૉલનો માર્જિન અર્થપૂર્ણ છે; નિષ્ફળ ચુકવણી સહનશીલ નુકસાન છે.
ગ્રાહકો આ ભાવ પર કઠોર વાટાઘાટ કરે છે; રિફંડની વિનંતીઓની અપેક્ષા રાખો.
સબ્સ્ક્રિપ્શન વિન્ડો
$5 - $50 પ્રતિ 24 કલાકની વિન્ડો (અથવા $X પ્રતિ મહિનો)ગ્રાહકો જે એક સત્રમાં ઘણા કોલ કરે છે અને પ્રતિ કોલ ચુકવણીમાં અવરોધ સહન નહીં કરે.
દરેક ગ્રાહક માટે વધુ આવક; પ્રતિ કોલ ઓવરહેડ ઓછું.
ઓછી શોધખોળ; ગ્રાહકોને અગાઉથી પ્રતિબદ્ધ થવું જોઈએ. ઘણીવાર હાઇબ્રિડ કિંમતો માટે પ્રતિ કૉલ સાથે સંયોજિત.
ઘણાં ઓપરેટર્સ પેટર્નને મિશ્રિત કરે છે: પ્રતિ-કોલ માઇક્રો-કિંમત પર સસ્તા ટૂલ્સ, પ્રતિ-કોલ ઉચ્ચ કિંમતો પર મોંઘા ટૂલ્સ, વધુ વપરાશકર્તાઓ માટે 24-કલાકની સબ્સ્ક્રિપ્શન વિન્ડો. કંઈપણ તમને એક જ MCP સર્વર પર ત્રણેય ચલાવવા અટકાવતું નથી; દરેક ટૂલ requirePayment માં તેની પોતાની amountUsdc અને તમારા હેન્ડલરમાં તેની પોતાની ચૂકવેલ-વિન્ડો સેટ કરે છે.
પ્રો લગભગ દરેક MCP સર્વર માટે યોગ્ય યોજના છે.
MCP સર્વર ઓપરેટર્સ લગભગ હંમેશા Pro પર શરૂ થાય છે કારણ કે API લખવા માટેની ઍક્સેસ અને વેબહૂક્સ પ્રથમ દિવસે જ જરૂરી છે: મફત વાંચન-માત્ર છે, અને એક ચૂકવેલ ટૂલને payment.received વેબહૂક્સ પ્રાપ્ત કરવા અને તેમને માન્ય કરવા માટેની જરૂર છે. ચોક્કસ પ્રતિ-એજન્ટ ખર્ચ અને ટ્રાન્ઝેક્શન-ફી સ્તરો ક્યાં બેઠા છે તે માટે કિંમતોના પૃષ્ઠને જુઓ; ટૂંકી આવૃત્તિ એ છે કે કોઈપણ સર્વર જે વાસ્તવિક ચૂકવેલ વોલ્યુમ કરે છે તે Pro પોતાને ચૂકવે છે તે બિંદુથી ખૂબ આગળ છે.
- Free: API અને dashboard સાથે experiment કરવા માટે ઉપયોગી. production paid tools માટે યોગ્ય નથી (read-only, no webhooks).
- Pro: live MCP servers માટે default. પૂર્ણ API access, webhooks, exports.
- Business: જ્યારે compliance માટે audit log જોઈએ, અથવા જ્યારે તમે અનેક clients માટે MCP servers ચલાવો અને per-agent team-seat sharing જોઈએ.