QRFLOW.codes

आधिकारिक

QR कोड बनाएं, मुद्रित डायनामिक कोड को पुनः निर्देशित करें, अपने स्वयं के डोमेन पर लिंक नाम दें, और स्कैन एनालिटिक्स पढ़ें।

QRFLOW Codes MCP के साथ आप क्या कर सकते हैं?

  • डायनामिक QR कोड बनाएँ — असिस्टेंट से destination_data के साथ url कोड बनाने और प्रिंट करने के लिए उसका short_url लौटाने को कहें।
  • प्रिंट किए गए कोड का गंतव्य बदलें — बिना दोबारा प्रिंट किए किसी मौजूदा डायनामिक कोड का रीडायरेक्ट गंतव्य बदलें, क्योंकि चित्र में short_url होता है।
  • कोड को रोकें या उसकी समय-सीमा समाप्त करें — हटाने के बजाय paused: true या समाप्ति तिथि सेट करें, ताकि प्रिंट किया गया लिंक सुरक्षित रूप से रीडायरेक्ट होना बंद कर दे।
  • स्कैन एनालिटिक्स देखें — किसी कोड के कुल Scans या प्रति दिन, प्रति देश और प्रति डिवाइस के हिसाब से विवरण प्राप्त करें।
  • अपने डोमेन पर लिंक को नाम दें — menu जैसा slug सेट करें और लिंक डोमेन चुनें, ताकि कोड go.example.com/menu के रूप में प्रिंट हो।
  • एक साथ कई कोड बनाएँ — सूची से हज़ारों डायनामिक कोड जनरेट करें और लौटाए गए कोड को लेबल के आधार पर पंक्तियों से जोड़ें।

होस्ट किया गया MCP सर्वर

npx add-mcp 'https://qrflow.codes/mcp'

Claude Code, Codex, Cursor और अन्य में इंस्टॉल होता है

दस्तावेज़

QRFLOW.codes डेवलपर्स के लिए

यहाँ से शुरू करें

QRFLOW.codes ऐसे QR कोड बनाता है जिन्हें प्रिंट करने के बाद बदला जा सकता है, आपके अपने डोमेन पर इस्तेमाल किया जा सकता है, जिनमें स्कैन एनालिटिक्स उपलब्ध हैं, और यह आपके सॉफ़्टवेयर तथा AI असिस्टेंट को एक API के ज़रिए ये सब करने देता है।

QR कोड किसी स्ट्रिंग की तस्वीर होता है। ज़्यादातर जनरेटर तस्वीर में आपका वेब पता डालते हैं; अगर पता बदल जाए, तो प्रिंट बेकार हो जाता है। QRFLOW तस्वीर में एक छोटा लिंक डालता है (go.yourbrand.com/menu या qrflow.codes/q/x7k2p9a) और उसे रीडायरेक्ट करता है। आप जब चाहें उसका गंतव्य बदल सकते हैं, और हर स्कैन गिना जाता है। यही डायनेमिक कोड है, और API के लिए यही उपयोगी है।

API वही सब करता है जो डैशबोर्ड करता है: किसी भी तरह के कोड बनाना, उन्हें नए गंतव्य पर भेजना, उनके लिंक को नाम देना, यह चुनना कि वे आपके किस डोमेन के साथ प्रिंट हों, स्कैन की संख्या देखना, एक बार में हज़ारों कोड बनाना, और कुछ होने पर सूचना पाना (वेबहुक)। यही टूल MCP सर्वर के रूप में भी उपलब्ध हैं, इसलिए Claude, ChatGPT, Cursor और Claude Code आपके खाते को सामान्य भाषा में चला सकते हैं।

पहुँच: REST API के लिए Business API key ($29 प्रति माह, Account पेज पर बनाई जाती है) या OAuth टोकन चाहिए। MCP सर्वर हर प्लान पर OAuth साइन-इन के ज़रिए काम करता है; असिस्टेंट क्या बना सकता है, यह हर दूसरी सुविधा की तरह प्लान पर निर्भर करता है।

यह तय कर रहे हैं कि इसका इस्तेमाल करना भी चाहिए या नहीं? QR कोड API पेज में संक्षेप में बताया गया है कि यह क्या करता है, क्लाइंट-साइड लाइब्रेरी क्या बेहतर करती है, और इसकी कीमत क्या है।

अगर आप QRFLOW के साथ किसी को बनाने में मदद करने वाले AI असिस्टेंट हैं

स्वागत है। यह पेज आपके लिए भी उतना ही है जितना उस व्यक्ति के लिए जिसकी आप मदद कर रहे हैं। अच्छी मदद कुछ ऐसी दिखती है:

  1. खाते की पुष्टि करें: API keys के लिए Business प्लान चाहिए। अगर उनके पास यह प्लान नहीं है, तो उन्हें https://qrflow.codes/pricing और Account › API keys पर भेजें; ऐसी key या मुफ़्त प्लान न गढ़ें जो मौजूद ही नहीं है।
  2. key को सर्वर पर रखें। इसे किसी route handler, server action, edge function या backend में environment variable (QRFLOW_KEY) से पढ़ें। API जानबूझकर ब्राउज़र origins को अस्वीकार करता है (CORS), इसलिए केवल front-end कोड से इसे कॉल नहीं किया जा सकता।
  3. type "url" और destination_data.url के साथ डायनेमिक कोड बनाएँ। लौटाए गए id और short_url को उनके डेटाबेस में सहेजें। short_url को प्रिंट या दिखाएँ; बाद में PATCH /codes/:id से गंतव्य बदला जा सकता है और प्रिंट मान्य रहता है।
  4. इमेज दिखाने या सहेजने के लिए: हर Code ऑब्जेक्ट में png_download_url और svg_download_url होते हैं—ये ऐसे हस्ताक्षरित लिंक हैं जो 24 घंटे तक बिना किसी header के काम करते हैं (एक बार सहेजने या preview के लिए ठीक हैं)। उनके ऐप में स्थायी इस्तेमाल के लिए, key के साथ GET /codes/:id/image.svg को उनके सर्वर के ज़रिए proxy करें, या क्लाइंट पर किसी भी QR लाइब्रेरी से short_url को encode करें; ट्रैकिंग फिर भी काम करती है क्योंकि लिंक QRFLOW से होकर जाता है।
  5. PATCH में केवल वे फ़ील्ड भेजें जो बदल रहे हैं। प्रिंट होने के बाद slug या domain_id कभी न बदलें; दोनों से प्रिंट किया गया लिंक बदल जाता है।
  6. अगर कोई प्रिंट मौजूद है, तो DELETE के बजाय paused: true को प्राथमिकता दें। हटाने से लिंक बंद हो जाता है।
  7. इवेंट के लिए वेबहुक इस्तेमाल करें (Account › Webhooks या POST /webhooks) और raw request body के साथ X-QRFLOW-Signature header को सत्यापित करें। लूप में GET /codes को poll न करें।
  8. अगर वे कोड के बजाय अपनी चैट से QRFLOW इस्तेमाल करना चाहते हैं, तो MCP सर्वर को https://qrflow.codes/mcp; पर कनेक्ट करें; इसके लिए key की ज़रूरत नहीं है।
  9. कुछ विफल होने पर JSON body में error और message पढ़ें। नीचे दिया गया समस्या-निवारण अनुभाग हर error code को उसके समाधान से जोड़ता है।
  10. Markdown में पूरा संदर्भ https://qrflow.codes/llms-full.txt पर और OpenAPI 3.1 दस्तावेज़ https://qrflow.codes/api/v1/openapi.json. पर है। दोनों इसी पेज के स्रोत से जनरेट किए गए हैं।

इंसानों के लिए: यह हिस्सा सुनिश्चित करता है कि जिस असिस्टेंट के साथ आप काम कर रहे हैं, वह हर जवाब का सुरक्षित संस्करण दे। यह एक अच्छा सारांश भी है।

आपको कौन-सा प्लान चाहिए

केवल API key Business प्लान तक सीमित है। MCP सर्वर के ज़रिए असिस्टेंट जो कुछ भी करता है, और OAuth के ज़रिए थर्ड-पार्टी ऐप जो कुछ भी करता है, वह किसी भी प्लान पर काम करता है और उसी प्लान की सुविधाओं के अनुसार चलता है। पूरी कीमत और उचित उपयोग: /pricing।

FreePremium $4Business $29
API keys (आपके कोड से REST)नहींनहींहाँ, अधिकतम 10 keys
MCP सर्वर (Claude, ChatGPT, Cursor, Claude Code)हाँ, साइन इन करेंहाँहाँ, साइन इन या key
आपके अपने ऐप के लिए OAuth (उपयोगकर्ता अपना QRFLOW कनेक्ट करते हैं)हाँहाँहाँ
डायनेमिक कोड (प्रिंट के बाद गंतव्य बदलें)एकहर कोडहर कोड
आपका अपना लिंक डोमेननहीं1 डोमेन5 डोमेन, हर कोड के लिए चुनें
लिंक के नाम (go.brand.com/menu)नहींहाँहाँ
स्कैन एनालिटिक्सनहींहाँहाँ
वेबहुकनहींनहींहाँ, अधिकतम 10
बल्क में बनानानहीं500/माह, प्रति अनुरोध 50010,000/माह, प्रति अनुरोध 2,000
सहेजे गए कोड (उचित उपयोग)कुछ1,00025,000
टीम सीटें115
कीमत$0$4/माह$29/माह

बारह शब्द जो सारा काम करते हैं

अवधारणाएँ

इन्हें एक बार पढ़ लें, फिर नीचे दिए गए हर endpoint का अर्थ समझ में आ जाएगा।

Static code

सामग्री तस्वीर के अंदर होती है। Wi-Fi, संपर्क कार्ड (vCard) और सादे टेक्स्ट वाले कोड हमेशा स्थिर होते हैं, और Free प्लान पर हर कोड स्थिर होता है। स्थिर कोड के लिए सर्वर की ज़रूरत नहीं होती, यह कभी समाप्त नहीं होता, और इसे बदला या गिना नहीं जा सकता।

Dynamic code

तस्वीर में एक छोटा लिंक होता है जिसे QRFLOW रीडायरेक्ट करता है। Premium और Business पर url, phone, email, sms और location कोड डायनेमिक होते हैं। प्रिंट को छुए बिना आप उनका गंतव्य बदल सकते हैं, उन्हें रोक सकते हैं, उनकी समय-सीमा तय कर सकते हैं, उनका नाम बदल सकते हैं और उन्हें गिन सकते हैं।

short_url

डायनेमिक कोड में encode की गई सटीक स्ट्रिंग, जिसे प्रिंट करना है। यह https://qrflow.codes/q/<short_code> होती है; डोमेन कनेक्ट करने के बाद यह https://<your domain>/<slug or short_code>. हो जाती है। हर Code ऑब्जेक्ट में यह मौजूद होती है।

short_code

सात रैंडम अक्षर, हर कोड के लिए अलग, बनाते समय असाइन किए जाते हैं और कभी नहीं बदलते। जब किसी कोड का लिंक नाम नहीं होता, तो यही वैकल्पिक पाथ होता है।

slug (link name)

आपके अपने डोमेन पर पढ़ने योग्य पाथ: go.example.com/menu। 3 से 40 छोटे अक्षर, अंक और डैश; आपके खाते में अद्वितीय; और केवल कनेक्ट किए गए डोमेन के साथ उपलब्ध। प्रिंट करने से पहले इसे सेट करें: इसे बदलने से प्रिंट किया गया लिंक बदल जाता है।

Link domain

आपका अपना hostname (go.example.com), जिसे CNAME के ज़रिए QRFLOW पर पॉइंट किया गया हो और Account पेज पर सत्यापित किया गया हो। Premium में एक डोमेन मिलता है; Business में पाँच और हर कोड के लिए domain_id चुनने की सुविधा मिलती है। सबसे पुराना सक्रिय डोमेन डिफ़ॉल्ट होता है।

Kind, type and subtype

type एन्कोडिंग बताता है: url, text, wifi, vcard, email, phone, sms, location। kind उस चीज़ का अधिक सहज नाम है जो लोग चाहते हैं (instagram, googlereview, whatsapp, pdf, menu, appstore,...). ज़्यादातर kind, destination_data.subtype सेट किए हुए url कोड होते हैं। GET /catalog हर kind और उसके फ़ील्ड की सूची देता है; Code में kind से पता चलता है कि वह कौन-सा है।

destination_data

type के फ़ील्ड, स्ट्रिंग के रूप में: वेबसाइट के लिए { url }, Wi-Fi के लिए { ssid, password, encryption }, Google review के लिए { placeId }, Instagram के लिए { handle }। डायनेमिक कोड पर आप इन्हें कभी भी बदल सकते हैं।

Scans

हर रीडायरेक्ट में अनुरोध से ही डिवाइस का प्रकार, देश, शहर, रेफ़रर, ब्राउज़र, OS और भाषा दर्ज होती है, साथ ही अद्वितीय विज़िटर गिनने के लिए रोज़ाना का एक-तरफ़ा hash भी। कोई cookie सेट नहीं होती और IP पता सहेजा नहीं जाता। Code में scans जीवनभर की कुल संख्या है; GET /codes/:id/scans इसका विवरण देता है।

Source

हर कोड में दर्ज रहता है कि उसे किसने बनाया: dashboard, api:<key name>, mcp, canva, app:<connected app> (उदाहरण के लिए app:Google Sheets) या bulk; बल्क अनुरोध से आने पर bulk: prefix के साथ। यह डैशबोर्ड और webhook payloads में दिखता है, ताकि आप अपने integration के कोड को हाथ से बनाए गए कोड से अलग पहचान सकें।

Workspace

Business का मालिक अधिकतम चार टीम सदस्यों को आमंत्रित कर सकता है। Keys और वेबहुक मालिक के खाते से जुड़े होते हैं; workspace में कोई भी बनाए गए कोड पूरी टीम को दिखते हैं।

पाँच मिनट

तुरंत शुरू करें

key प्राप्त करें

  1. Business प्लान पर, Account › API keys खोलें।
  2. key का नाम उस काम के अनुसार रखें जिसके लिए वह है ("Shop backend", "Reporting") और उसके scopes चुनें। Scopes बाद में बदले नहीं जा सकते; अधिक scopes चाहिए हों तो नई key बनाएँ।
  3. इसे एक बार कॉपी करें। यह qrf_live_… जैसी दिखती है। इसे QRFLOW_KEY नाम के environment variable में रखें।
  4. हर अनुरोध पर इसे Authorization: Bearer $QRFLOW_KEY के रूप में भेजें। प्रमाणीकरण की पूरी प्रक्रिया बस इतनी ही है।

Keys सर्वर के लिए हैं। इन्हें कभी वेब पेज, मोबाइल ऐप या साझा स्प्रेडशीट में न रखें; अगर कोई key लीक हो जाए, तो उसे रद्द करके नई key जारी करें।

curl, TypeScript और Python में यही पाँच चरण। हर उदाहरण एक डायनेमिक कोड बनाता है, उसकी इमेज डाउनलोड करता है, उसका गंतव्य बदलता है और उसके स्कैन पढ़ता है।

export QRFLOW_KEY=qrf_live_...   # from Account › API keys

# 1. Who am I, what can this key do?
curl https://qrflow.codes/api/v1/me -H "Authorization: Bearer $QRFLOW_KEY"

# 2. Make a dynamic code. Print what comes back as short_url.
curl -X POST https://qrflow.codes/api/v1/codes \
  -H "Authorization: Bearer $QRFLOW_KEY" -H "Content-Type: application/json" \
  -d '{ "type": "url", "destination_data": { "url": "https://example.com/menu" }, "label": "Table tents" }'

# 3. The print-ready image (SVG, with your colors and frame).
curl "https://qrflow.codes/api/v1/codes/$CODE_ID/image.svg?size=1024" \
  -H "Authorization: Bearer $QRFLOW_KEY" -o menu.svg

# 4. Fall menu. The printed code keeps working.
curl -X PATCH https://qrflow.codes/api/v1/codes/$CODE_ID \
  -H "Authorization: Bearer $QRFLOW_KEY" -H "Content-Type: application/json" \
  -d '{ "destination_data": { "url": "https://example.com/menu-fall" } }'

# 5. How did it do?
curl "https://qrflow.codes/api/v1/codes/$CODE_ID/scans?group=day" -H "Authorization: Bearer $QRFLOW_KEY"

TypeScript (Node 18+, Bun, Deno, Workers)

// npm install qrflow   (zero dependencies; ESM + CommonJS; full types)
import { QRFlow, QRFlowError } from "qrflow";

const qr = new QRFlow(process.env.QRFLOW_KEY!);

const { code } = await qr.createCode({
  type: "url",
  destination_data: { url: "https://example.com/menu" },
  label: "Table tents",
});
console.log(code.id, code.short_url);        // save both; print short_url

await qr.updateCode(code.id, { destination_data: { url: "https://example.com/menu-fall" } });

const stats = await qr.scans(code.id, { group: "day" });
console.log(stats.total, stats.rows);         // [{ key: "2026-09-21", scans: 18 }, ...]

try {
  await qr.updateCode(code.id, { slug: "menu" });
} catch (e) {
  if (e instanceof QRFlowError) console.log(e.status, e.code, e.message); // 400 no_domain: connect a domain first
}
# Download https://qrflow.codes/sdk/qrflow.py next to your code.
import os
from qrflow import QRFlow, QRFlowError

qr = QRFlow(os.environ["QRFLOW_KEY"])

code = qr.create_code(type="url", destination_data={"url": "https://example.com/menu"}, label="Table tents")["code"]
print(code["id"], code["short_url"])          # save both; print short_url

qr.update_code(code["id"], destination_data={"url": "https://example.com/menu-fall"})

stats = qr.scans(code["id"], group="day")
print(stats["total"], stats["rows"])

try:
    qr.update_code(code["id"], slug="menu")
except QRFlowError as e:
    print(e.status, e.code, e)                # 400 no_domain: connect a domain first

प्रमाणीकरण

API keys (Business)

हर खाते में अधिकतम 10, हर एक के लिए 600 अनुरोध प्रति मिनट, hashed रूप में संग्रहीत, और केवल एक बार दिखाई जाती हैं। हर key में वे scopes होते हैं जिनके साथ उसे बनाया गया था:

Scopeअनुमति
profileGET /me: प्लान, सुविधाएँ, सीमाएँ। हर key में यह scope होता है।
codes:readकोड सूचीबद्ध करना और पढ़ना, इमेज डाउनलोड करना।
codes:writeकोड बनाना, बदलना, डायनेमिक बनाना, हटाना और बल्क में बनाना।
analytics:readGET /codes/:id/scans।
domains:readGET /domains (domain_id का सही इस्तेमाल करने के लिए ज़रूरी)।
codes:read / codes:writeGS1 उत्पादों के लिए भी: /products endpoints कोड scopes साझा करते हैं, इसलिए कोड प्रबंधित करने वाली key पैकेजिंग कोड भी प्रबंधित करती है।
webhooks:manageवेबहुक सूचीबद्ध करना, बनाना, जाँचना और हटाना।

OAuth 2.0 (किसी भी प्लान पर, ऐप और असिस्टेंट के लिए)

जब कोड आपके बजाय आपके उपयोगकर्ताओं के खातों से जुड़े होने चाहिए, या जब चैट असिस्टेंट क्लाइंट हो, तो OAuth इस्तेमाल करें। क्लाइंट अपना पंजीकरण करते हैं; सार्वजनिक क्लाइंट के लिए PKCE S256 ज़रूरी है; टोकन को MCP सर्वर से resource= के ज़रिए बाँधा जा सकता है। OAuth गाइड में पूरी प्रक्रिया दी गई है।

EndpointURLनोट
Authorizationhttps://qrflow.codes/oauth/authorizeउपयोगकर्ता को यहाँ भेजें; वे साइन इन करके Allow दबाएँगे।
Tokenhttps://qrflow.codes/api/oauth/tokenauthorization_code और refresh_token grants। Access token 1 घंटे और refresh token 90 दिन तक मान्य रहते हैं।
Revokehttps://qrflow.codes/api/oauth/revokeRFC 7009। उपयोगकर्ता Account › Connected apps से भी कनेक्शन हटा सकते हैं।
क्लाइंट पंजीकृत करेंhttps://qrflow.codes/api/oauth/registerRFC 7591 डायनेमिक पंजीकरण; खाते की ज़रूरत नहीं। सार्वजनिक क्लाइंट को dyn_ client_id मिलता है और उन्हें PKCE S256 इस्तेमाल करना होता है।
Discoveryhttps://qrflow.codes/.well-known/oauth-authorization-serverRFC 8414। MCP resource दस्तावेज़ /.well-known/oauth-protected-resource पर है।

Access token 1 घंटे और refresh token 90 दिन तक मान्य रहते हैं। उपयोगकर्ता Account › Connected apps में कनेक्ट किए गए ऐप देख सकते हैं और कभी भी कनेक्शन हटा सकते हैं। https://qrflow.codes/mcp के लिए जारी किया गया टोकन /api/v1 पर अस्वीकार कर दिया जाता है, और इसका उलटा भी।

वे चीज़ें जिनके लिए लोग सचमुच पूछते हैं

बनाने की रेसिपी

हर रेसिपी पूरी है और सीधे काम करने वाले कोड से ली गई है। अपने stack के अनुसार चुनें; तरीका हमेशा एक जैसा है: key के साथ सर्वर-साइड कॉल करें, id और short_url सहेजें, और इमेज दिखाएँ।

Next.js: कोड बनाने वाला route और उसे दिखाने वाला route

कब इस्तेमाल करें: आपके पास Next.js ऐप (App Router) है और आप ऐसा बटन चाहते हैं जो QR कोड बनाए, साथ ही ऐसा पेज जो उसे दिखाए।

  1. अपनी key को .env.local में QRFLOW_KEY के रूप में रखें। इसे कभी NEXT_PUBLIC_ से शुरू न करें।
  2. एक POST route handler जोड़ें जो कोड बनाए और id तथा short_url लौटाए।
  3. एक GET route जोड़ें जो इमेज को proxy करे, ताकि ब्राउज़र को key कभी न दिखे।
  4. id और short_url को अपने रिकॉर्ड (ऑर्डर, टेबल, उत्पाद, इवेंट) में सहेजें।
import { NextResponse } from "next/server";

export async function POST(req: Request) {
  const { url, label } = await req.json();
  const r = await fetch("https://qrflow.codes/api/v1/codes", {
    method: "POST",
    headers: { Authorization: \`Bearer ${process.env.QRFLOW_KEY}\`, "Content-Type": "application/json" },
    body: JSON.stringify({ type: "url", destination_data: { url }, label }),
  });
  const data = await r.json();
  if (!r.ok) return NextResponse.json(data, { status: r.status }); // { error, message }
  return NextResponse.json({ id: data.code.id, short_url: data.code.short_url });
}
// Proxies the SVG so the key stays on the server. Check that the signed-in
// user owns this id before you serve it, or anyone with an id can fetch it.
export async function GET(_: Request, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const r = await fetch(\`https://qrflow.codes/api/v1/codes/${id}/image.svg?size=1024\`, {
    headers: { Authorization: \`Bearer ${process.env.QRFLOW_KEY}\` },
  });
  return new Response(r.body, {
    status: r.status,
    headers: { "Content-Type": "image/svg+xml", "Cache-Control": "private, max-age=3600" },
  });
}
<img src={\`/api/qr/${code.id}/image\`} alt={\`QR code for ${code.label}\`} width={256} height={256} />
<a href={code.short_url}>{code.short_url}</a>
  • Server Actions भी इसी तरह काम करते हैं: action के अंदर key के साथ fetch कॉल करें।
  • Pages Router के लिए, यही कोड pages/api/qr.ts में req/res के साथ रखें।

प्रॉक्सी किए बिना QR दिखाएँ: short_url को खुद रेंडर करें

कब: आप चाहते हैं कि इमेज तुरंत ब्राउज़र में दिखे और उस पर QRFLOW के frames या logo की ज़रूरत न हो।

कोई भी QR लाइब्रेरी काम करती है, क्योंकि कोड ही short link है

import QRCode from "qrcode"; // npm i qrcode

// short_url came back from POST /codes. Encode it as-is.
const dataUrl = await QRCode.toDataURL(code.short_url, { width: 512, margin: 2 });
// <img src={dataUrl} />  scans go through QRFLOW, so analytics and re-pointing still work.
  • प्रीव्यू के लिए यह सबसे तेज़ तरीका है। प्रिंट के लिए /codes/:id/image.svg डाउनलोड करें: इसमें सेव किए गए रंग, frame, captions और logo होते हैं, और यह vector है।
  • अगर बाद में slug या domain_id बदलते हैं, तो short_url बदल जाता है; इसे फिर से रेंडर करें।

Express या कोई भी Node सर्वर

कब: एक साधारण Node backend।

import express from "express";
const app = express();
app.use(express.json());
const H = { Authorization: \`Bearer ${process.env.QRFLOW_KEY}\`, "Content-Type": "application/json" };

app.post("/qr", async (req, res) => {
  const r = await fetch("https://qrflow.codes/api/v1/codes", {
    method: "POST", headers: H,
    body: JSON.stringify({ type: "url", destination_data: { url: req.body.url }, label: req.body.label }),
  });
  res.status(r.status).json(await r.json());
});

app.get("/qr/:id.svg", async (req, res) => {
  const r = await fetch(\`https://qrflow.codes/api/v1/codes/${req.params.id}/image.svg\`, { headers: H });
  res.status(r.status).type("image/svg+xml").send(await r.text());
});

app.listen(3000);

Cloudflare Workers, Vercel Edge, Deno Deploy, Supabase Edge Functions

कब: ऐसा fetch-only runtime जिसमें Node built-ins न हों।

export default {
  async fetch(req: Request, env: { QRFLOW_KEY: string }) {
    const { url, label } = await req.json();
    const r = await fetch("https://qrflow.codes/api/v1/codes", {
      method: "POST",
      headers: { Authorization: \`Bearer ${env.QRFLOW_KEY}\`, "Content-Type": "application/json" },
      body: JSON.stringify({ type: "url", destination_data: { url }, label }),
    });
    return new Response(r.body, { status: r.status, headers: { "Content-Type": "application/json" } });
  },
};
Deno.serve(async (req) => {
  const { url, label } = await req.json();
  const r = await fetch("https://qrflow.codes/api/v1/codes", {
    method: "POST",
    headers: { Authorization: \`Bearer ${Deno.env.get("QRFLOW_KEY")}\`, "Content-Type": "application/json" },
    body: JSON.stringify({ type: "url", destination_data: { url }, label }),
  });
  return new Response(await r.text(), { status: r.status, headers: { "Content-Type": "application/json" } });
});
// supabase secrets set QRFLOW_KEY=qrf_live_...
  • npm package qrflow\ केवल fetch और WebCrypto का उपयोग करता है, इसलिए यह इन सभी में बिना बदलाव के चलता है।

Python: FastAPI, Flask, Django, कोई script

कब: आपका backend Python में है।

import os
from fastapi import FastAPI, HTTPException, Response
from qrflow import QRFlow, QRFlowError   # https://qrflow.codes/sdk/qrflow.py

app = FastAPI()
qr = QRFlow(os.environ["QRFLOW_KEY"])

@app.post("/qr")
def make_qr(url: str, label: str | None = None):
    try:
        code = qr.create_code(type="url", destination_data={"url": url}, label=label)["code"]
    except QRFlowError as e:
        raise HTTPException(e.status, {"error": e.code, "message": str(e)})
    return {"id": code["id"], "short_url": code["short_url"]}

@app.get("/qr/{code_id}.svg")
def qr_image(code_id: str):
    import urllib.request
    req = urllib.request.Request(qr.image_url(code_id), headers={"Authorization": f"Bearer {os.environ['QRFLOW_KEY']}"})
    with urllib.request.urlopen(req) as r:
        return Response(r.read(), media_type="image/svg+xml")

हर order, table, product, ticket या event के लिए एक QR code

कब: आपकी किसी table की हर row के लिए अपना code चाहिए, जो अपने-आप बनाया जाए।

  1. अपनी table में दो columns जोड़ें: qrflow_code_id (uuid) और qr_short_url (text)।
  2. जब कोई row बनाई जाए, तो row के public URL और row का नाम बताने वाले label ("Order 10432", "Table 7") के साथ POST /codes करें। id और short_url सेव करें।
  3. जब row का page बदलता है (नया domain, नया path), तो destination_data को PATCH करें। प्रिंट किए गए codes काम करते रहेंगे।
  4. जब row को हटाया जाए, तो अगर कुछ प्रिंट किया गया था तो PATCH { paused: true } करें; अगर कुछ भी प्रिंट नहीं किया गया था, तभी DELETE करें।
  5. एक बार में हज़ारों चाहिए (300 restaurants के लिए हर table का menu)? POST /codes/bulk को chunks में इस्तेमाल करें और लौटाए गए codes को label या order के आधार पर अपनी rows से मिलाएँ।
const { code } = await qr.createCode({
  type: "url",
  destination_data: { url: \`https://example.com/orders/${order.id}\` },
  label: \`Order ${order.number}\`,
});
await db.orders.update(order.id, { qrflow_code_id: code.id, qr_short_url: code.short_url });
  • Business पर उचित उपयोग की सीमा 25,000 सेव किए गए codes है; API इसकी दोगुनी संख्या पर रुक जाती है। अगर आपको हमेशा के लिए हर receipt के लिए एक code चाहिए, तो पहले हमसे बात करें: hello@qrflow.codes।

प्रिंट किए गए code का गंतव्य बदलें

कब: कोई campaign खत्म हो गया, page बदल गया, PDF बदल दी गई या season बदल गया।

curl -X PATCH https://qrflow.codes/api/v1/codes/$CODE_ID \
  -H "Authorization: Bearer $QRFLOW_KEY" -H "Content-Type: application/json" \
  -d '{ "destination_data": { "url": "https://example.com/spring" } }'

इसे रोकें या इसकी समाप्ति की तारीख दें

# Scans show a "paused" page instead of redirecting
curl -X PATCH https://qrflow.codes/api/v1/codes/$CODE_ID -H "Authorization: Bearer $QRFLOW_KEY" \
  -H "Content-Type: application/json" -d '{ "paused": true }'

# Stops working after the date; null clears it
curl -X PATCH https://qrflow.codes/api/v1/codes/$CODE_ID -H "Authorization: Bearer $QRFLOW_KEY" \
  -H "Content-Type: application/json" -d '{ "expires_at": "2026-12-31T23:59:59Z" }'
  • केवल dynamic codes को नए गंतव्य पर भेजा जा सकता है; किसी भी static code पर 400 not_dynamic मिलता है। Wi-Fi, vCard और plain text codes अपना content pattern में रखते हैं और कभी dynamic नहीं हो सकते, इसलिए POST /codes/:id/dynamic उन्हें 400 not_dynamic_capable के साथ अस्वीकार करता है। url, phone, email, sms और location codes के लिए, Free में पहला code dynamic और बाकी static होते हैं; paid plan पर हर code dynamic होता है। जब तक account में allowance है, POST /codes/:id/dynamic किसी static code को dynamic में बदल देता है। इसके बाद फिर से रेंडर और प्रिंट करें, क्योंकि तस्वीर बदल जाती है।
  • अगली scan पर scanner को नया गंतव्य दिखेगा। इंतज़ार करने के लिए कोई cache नहीं है।

अपने domain पर codes प्रिंट करें

कब: आप चाहते हैं कि code में qrflow.codes/q/x7k2p9a के बजाय go.example.com/menu हो।

  1. Account page पर, Your own link domain के नीचे go.example.com जोड़ें और अपने DNS provider पर दिखाया गया CNAME बनाएँ। सत्यापन आमतौर पर कुछ मिनटों में पूरा हो जाता है।
  2. इसके बाद हर नए dynamic code का short_url उस domain का उपयोग करेगा। मौजूदा codes भी बदल जाते हैं: उनकी तस्वीर में qrflow.codes/q/... encode था, जो redirect करता रहता है, इसलिए प्रिंट की गई कोई चीज़ काम करना बंद नहीं करती।
  3. slug के साथ codes को पढ़ने योग्य नाम दें: PATCH { "slug": "menu" } से go.example.com/menu बनता है। प्रिंट करने से पहले ऐसा करें।
  4. कई domains वाले Business plan पर, GET /domains उन्हें ids के साथ सूचीबद्ध करता है; हर code के लिए domain चुनने हेतु POST या PATCH में domain_id दें।

Link को नाम दें और domain चुनें

curl https://qrflow.codes/api/v1/domains -H "Authorization: Bearer $QRFLOW_KEY"
# { "default_base": "https://go.example.com", "domains": [ { "id": "…", "host": "go.example.com", "is_default": true, … }, { "id": "…", "host": "qr.example.fr", … } ] }

curl -X PATCH https://qrflow.codes/api/v1/codes/$CODE_ID -H "Authorization: Bearer $QRFLOW_KEY" -H "Content-Type: application/json" \
  -d '{ "slug": "menu", "domain_id": "<id of qr.example.fr>" }'
# short_url is now https://qr.example.fr/menu

अपने admin में scan chart

कब: आप अपने आँकड़ों के साथ-साथ प्रति दिन, देश या device के अनुसार scans देखना चाहते हैं।

const stats = await qr.scans(code.id, { from: "2026-09-01", to: "2026-09-30", group: "day" });
// stats.total -> 412
// stats.rows  -> [{ key: "2026-09-01", scans: 18 }, { key: "2026-09-02", scans: 25 }, ...]
// Feed rows straight into Recharts, Chart.js, or a <table>.

const byCountry = await qr.scans(code.id, { group: "country" });   // [{ key: "US", scans: 300 }, { key: "MX", scans: 41 }]
const byDevice  = await qr.scans(code.id, { group: "device" });    // mobile, desktop, tablet
  • एक request में अधिकतम 92 दिन शामिल होते हैं; लंबी अवधि के लिए loop करें। तारीखें UTC में हैं।
  • polling के बिना live आँकड़ों के लिए, scan event पर webhook subscribe करें: आपको हर कुछ मिनट में batches में, हर scan की जानकारी मिलती है।

Next.js में webhooks पाएँ और उन्हें verify करें

कब: आप जानना चाहते हैं कि कोई code कब scan या बदला गया, अपने database में, लगभग real time में।

  1. Account › Webhooks पर या POST /webhooks से webhook बनाएँ। secret (whsec_...) को QRFLOW_WEBHOOK_SECRET में एक बार कॉपी करें।
  2. Parse करने से पहले raw body को text के रूप में पढ़ें; signature में ठीक वही bytes शामिल होते हैं।
  3. Verify करें, फिर event के अनुसार कार्रवाई करें। जल्दी 2xx जवाब दें; धीमा काम जवाब देने के बाद या queue में करें।
  4. Signed ping पाने और wiring की पुष्टि करने के लिए webhook पर Test दबाएँ।
import { createHmac, timingSafeEqual } from "node:crypto";

function verify(raw: string, header: string, secret: string): boolean {
  const t = /t=(\d+)/.exec(header)?.[1], v1 = /v1=([a-f0-9]+)/.exec(header)?.[1];
  if (!t || !v1 || Math.abs(Date.now() / 1000 - Number(t)) > 300) return false;
  const expected = createHmac("sha256", secret).update(\`${t}.${raw}\`).digest("hex");
  return expected.length === v1.length && timingSafeEqual(Buffer.from(expected), Buffer.from(v1));
}

export async function POST(req: Request) {
  const raw = await req.text();
  if (!verify(raw, req.headers.get("x-qrflow-signature") ?? "", process.env.QRFLOW_WEBHOOK_SECRET!)) {
    return new Response("bad signature", { status: 401 });
  }
  const evt = JSON.parse(raw) as { id: string; event: string; created_at: string; data: any };
  // evt.id is stable across retries: store it and skip duplicates.

  switch (evt.event) {
    case "scan":          // evt.data.scans[]: code_id, label, slug, scanned_at, device, country, city, referrer, browser, os, language
      break;
    case "code.created":  // evt.data.code, evt.data.source
    case "code.updated":  // evt.data.code, evt.data.changed[]
    case "code.deleted":  // evt.data.code { id, label, short_code, slug }
      break;
    case "ping":          // the Test button
      break;
  }
  return new Response(null, { status: 204 });
}
  • स्थानीय रूप से, tunnel के ज़रिए अपना dev server उपलब्ध कराएँ (cloudflared tunnel --url http://localhost:3000, या ngrok) और बनाते समय webhook के लिए उस https URL का उपयोग करें।
  • npm package यह काम आपके लिए करता है: import { parseWebhook } from "qrflow"\ एक ही call में verify और parse करता है (WebCrypto के कारण यह Workers और Deno में भी चलता है)। Python client में verify_webhook शामिल है।

Python में webhooks पाएँ

कब: Flask, FastAPI या Django में वही events प्राप्त करना।

import os, json
from flask import Flask, request, abort
from qrflow import verify_webhook   # https://qrflow.codes/sdk/qrflow.py

app = Flask(__name__)

@app.post("/qrflow")
def hook():
    raw = request.get_data()  # bytes, before any parsing
    if not verify_webhook(raw, request.headers.get("X-QRFLOW-Signature", ""), os.environ["QRFLOW_WEBHOOK_SECRET"]):
        abort(401)
    evt = json.loads(raw)
    if evt["event"] == "scan":
        for s in evt["data"]["scans"]:
            print(s["code_id"], s["scanned_at"], s["country"], s["device"])
    return "", 204

CSV से हज़ारों codes

कब: हर SKU, seat, asset tag या mailer के लिए एक code चाहिए।

import { parse } from "csv-parse/sync";
import { readFileSync } from "node:fs";

const rows = parse(readFileSync("skus.csv"), { columns: true }) as Array<{ sku: string; url: string }>;
const out: Array<{ sku: string; id: string; short_url: string }> = [];

for (let i = 0; i < rows.length; i += 2000) {                 // Business: 2,000 per request
  const chunk = rows.slice(i, i + 2000);
  const { codes, rejected, remaining_this_month } = await qr.bulkCreate(
    chunk.map((r) => ({ destination: r.url, label: r.sku })),
  );
  codes.forEach((c, j) => out.push({ sku: chunk[j].sku, id: c.id, short_url: c.short_url }));
  if (rejected.length) console.warn(rejected);                  // rows that were not web addresses
  console.log(remaining_this_month, "left this month");
}
  • Bulk केवल dynamic url codes बनाता है, और सभी में एक जैसे रंग होते हैं। Codes आपके भेजे गए क्रम में लौटते हैं, अस्वीकृत rows को छोड़कर; संदेह होने पर label से मिलाएँ।
  • हर code के लिए एक event के बजाय, webhooks को हर bulk request पर codes[] के साथ एक code.created event मिलता है।

अपने उपयोगकर्ताओं को उनका QRFLOW account कनेक्ट करने दें (OAuth)

कब: आप दूसरे लोगों के लिए product बना रहे हैं और चाहते हैं कि codes आपके account के बजाय उनके QRFLOW accounts में जाएँ।

  1. एक बार client रजिस्टर करें: client_name और redirect_uris के साथ POST https://qrflow.codes/api/oauth/register करें। आपको client_id (और confidential clients के लिए client_secret) मिलेगा।
  2. उपयोगकर्ता को response_type=code, client_id, redirect_uri, scope, state और PKCE (code_challenge, code_challenge_method=S256) के साथ /oauth/authorize पर भेजें।
  3. /api/oauth/token पर code का आदान-प्रदान करें। Refresh token सेव करें; access tokens एक घंटे तक चलते हैं।
  4. Authorization: Bearer <access_token> के साथ /api/v1 कॉल करें। उपयोगकर्ता के plan के तहत, key के साथ सब कुछ ठीक उसी तरह काम करता है।
curl -X POST https://qrflow.codes/api/oauth/register -H "Content-Type: application/json" \
  -d '{ "client_name": "Acme Menus", "redirect_uris": ["https://app.example.com/oauth/qrflow"], "token_endpoint_auth_method": "none" }'
# { "client_id": "dyn_…", "redirect_uris": [...], "grant_types": ["authorization_code","refresh_token"], … }
https://qrflow.codes/oauth/authorize?response_type=code&client_id=dyn_…&redirect_uri=https%3A%2F%2Fapp.example.com%2Foauth%2Fqrflow
  &scope=profile%20codes%3Aread%20codes%3Awrite%20analytics%3Aread&state=…&code_challenge=…&code_challenge_method=S256
  • Scopes API keys वाले वही छह हैं। जितनी ज़रूरत हो उतनी ही माँगें; consent screen उन्हें सूचीबद्ध करती है।
  • अगर आपका app chat assistant या agent है, तो authorize request में resource=https://qrflow.codes/mcp जोड़ें और इसके बजाय MCP server से बात करें; token उसी से बँधा होगा।

Zapier, Make, n8n: बिल्कुल बिना code के

कब: आप चाहते हैं कि scans या नए codes किसी sheet, Slack channel या CRM में पहुँचें।

  1. Catch-hook trigger बनाएँ (Zapier: Webhooks by Zapier › Catch Hook; Make: Custom webhook; n8n: Webhook node) और उसका https URL कॉपी करें।
  2. Account › Webhooks पर वह URL जोड़ें और events चुनें। Test दबाएँ; ping tool में दिखाई देगा और payload का स्वरूप बताएगा।
  3. data.scans[] (scan के लिए) या data.code (code.*) को अपनी sheet, message या record से map करें।
  4. इन tools से codes बनाने के लिए, Authorization header के साथ POST /codes पर उनके HTTP module का उपयोग करें। Key को tool के credential store में रखें।
  • Zapier पर अब QRFLOW.codes app उपलब्ध है: इसके Create QR Code, Update QR Code और Find steps तथा instant New Scan trigger के लिए webhook setup या API key की ज़रूरत नहीं है। QRFLOW with Zapier देखें। नीचे दिए गए steps Make, n8n और बाकी सभी के लिए हैं।
  • ये tools signature verify नहीं कर सकते। वे आपको जो URL देते हैं, उसका अनुमान नहीं लगाया जा सकता; यही आपकी सुरक्षा है। इसे कहीं भी पोस्ट न करें।
  • अगर सूची पहले से Google Sheets में है, तो शायद आपको webhook की ज़रूरत ही न हो: QRFLOW for Google Sheets add-on, Premium पर, बिना API key के हर row के लिए code बनाता है और short link तथा scan count को वापस sheet में लिखता है। Google Sheets add-on देखें।

Vibe coding

कॉपी करके इस्तेमाल करने के लिए prompts

Coding assistants को शुरुआत में ही नियम बता दिए जाएँ, तो वे सही चीज़ बनाते हैं। इन prompts में नियम शामिल हैं। किसी एक को paste करें, bracket भरें, और assistant एक भी line लिखने से पहले Markdown reference पढ़ेगा।

मेरे app में QR codes जोड़ें

Claude, ChatGPT, Cursor, Codex, Windsurf, Copilot Chat: chat में paste करें

Add QR codes to this project using the QRFLOW.codes API.

Read https://qrflow.codes/llms-full.txt before writing code; it is the complete reference.

Rules:
- The API key is in the environment variable QRFLOW_KEY. It must only be used server-side (route handler, server action, edge function). Never expose it to the browser.
- Create dynamic codes: POST https://qrflow.codes/api/v1/codes with { "type": "url", "destination_data": { "url": ... }, "label": ... }.
- Save the returned code.id and code.short_url on my record. short_url is what gets printed or displayed.
- Show the image by proxying GET /codes/:id/image.svg through my server, or by encoding short_url with a QR library on the client.
- Handle errors from the JSON body: { "error", "message" }. Map 402 to "upgrade needed", 429 to a retry with the Retry-After header.

What I want: [describe the feature, e.g. "every event in my events table gets a QR code that opens its public page; show it on the event admin page with a download button"].

अपने repo को QRFLOW के बारे में बताएँ

इसे CLAUDE.md, AGENTS.md,.cursorrules या.github/copilot-instructions.md में डालें

## QR codes (QRFLOW.codes)
- Docs: https://qrflow.codes/llms-full.txt (Markdown), https://qrflow.codes/api/v1/openapi.json (OpenAPI 3.1).
- Base URL https://qrflow.codes/api/v1, header Authorization: Bearer $QRFLOW_KEY. Server-side only.
- Codes are created with POST /codes { type: "url", destination_data: { url }, label }. Store code.id and code.short_url.
- Change the destination with PATCH /codes/:id { destination_data: { url } }. Never change slug/domain_id after printing.
- Image: GET /codes/:id/image.svg (needs the key). Prefer paused: true over DELETE when a print exists.
- Webhooks arrive as POST with X-QRFLOW-Signature (t=,v1=HMAC-SHA256 of "t.rawBody"); verify with the raw body.

Lovable, Bolt, v0, Replit और अन्य app builders में

ऐसे front-end-first builders जो आपको backend देते हैं (Supabase, serverless functions)

Integrate QRFLOW.codes QR codes. The API refuses browser calls, so create a backend function (Supabase Edge Function / serverless function) that holds the secret QRFLOW_KEY and calls POST https://qrflow.codes/api/v1/codes with { "type": "url", "destination_data": { "url": "<the page URL>" }, "label": "<name>" }. Return code.id and code.short_url to the UI and save them in the database. Render the QR in the UI by encoding short_url with a QR library; add a "Download for print" button that fetches /codes/:id/image.svg through the same backend function. Reference: https://qrflow.codes/llms-full.txt

एक custom GPT जो मेरे codes मैनेज करे

ChatGPT › Create a GPT › Actions

Import from URL: https://qrflow.codes/api/v1/openapi.json
Authentication: API Key › Bearer › paste a Business key with the scopes you want the GPT to have.
Then the GPT can list, create, re-point and report on your codes. For a no-setup version, add the MCP connector instead (Developer mode › Plugins › https://qrflow.codes/mcp).

Connector चालू होने के बाद कहने के लिए बातें

Claude, ChatGPT, QRFLOW MCP server से जुड़ा Claude Code

"Make a QR code for https://example.com/fall-menu, call it Fall menu, frame caption 'Scan for menu'."
"Which of my codes got the most scans this month? Show a breakdown by country for the top one."
"Point the 'Lobby poster' code at https://example.com/events/october."
"Name the 'Business card' code's link 'hi' on my domain."
"Pause every code with 'Summer' in the label."
"Make 40 codes, one per table, going to https://example.com/order?table=1 through 40."
"Show me the PNG of the 'Front door' code."

MCP server

Claude, ChatGPT, Cursor और Claude Code से इसका उपयोग करें

QRFLOW, https://qrflow.codes/mcp पर एक MCP server है। इसे एक बार कनेक्ट करें, sign in करें, फिर ऐसी बातें कहें: "हमारे fall menu page के लिए QR code बनाओ, जिसका नाम मेरे domain पर menu हो", "lobby poster के code को नए page पर भेजो" या "पिछले हफ़्ते flyer को कितने scans मिले, देश के अनुसार?"। Assistant को वही tools मिलते हैं जो यह API देती है, उन्हीं नियमों के तहत, और codes आपके dashboard में mcp को source के रूप में दिखाते हुए पहुँचते हैं।

Developer नहीं हैं? हर assistant के लिए सटीक क्लिक के साथ सरल भाषा में जानकारी Make QR codes with your AI assistant पर है।

Glama द्वारा स्वतंत्र रूप से स्कोर किया गया और हर घंटे health-check किया जाता है। यह awesome-remote-mcp-servers directory और आधिकारिक MCP Registry में codes.qrflow/qrflow के रूप में सूचीबद्ध है।

कनेक्ट करें

Customize › Connectors › Add custom connector › address paste करें, या QRFLOW की directory listing पर Connect दबाएँ। Claude, QRFLOW sign-in खोलेगा; Allow दबाएँ। हर plan पर काम करता है।

https://qrflow.codes/mcp

Settings › Security and login › Developer mode चालू करें, फिर Settings › Plugins › + › address paste करें; पूछे जाने पर sign in करें। Plus, Pro, Team, Enterprise और Edu।

https://qrflow.codes/mcp

एक command, फिर sign in करने के लिए /mcp। Sign-in छोड़ने के लिए header के रूप में Business key जोड़ें।

claude mcp add --transport http qrflow https://qrflow.codes/mcp
# or, with a key:
claude mcp add --transport http qrflow https://qrflow.codes/mcp --header "Authorization: Bearer $QRFLOW_KEY"

Cursor, Windsurf, VS Code, कोई भी MCP client

URL पर HTTP server जोड़ें। OAuth sign-in browser में होता है; या key के साथ Authorization header दें।

{
  "mcpServers": {
    "qrflow": { "type": "http", "url": "https://qrflow.codes/mcp" }
  }
}

आपका अपना agent (Anthropic या OpenAI SDK)

MCP connector या tool को URL पर Business key को bearer के रूप में देकर सेट करें; browser flow की ज़रूरत नहीं।

// Anthropic Messages API, MCP connector
mcp_servers: [{ type: "url", url: "https://qrflow.codes/mcp", name: "qrflow", authorization_token: process.env.QRFLOW_KEY }]

Assistant क्या कर सकता है

Toolयह क्या करता हैScope
list_code_kindsहर तरह के code, उसके fields और ज़रूरी plan की जानकारी। कोई असामान्य चीज़ बनाने से पहले assistant इसे कॉल करता है।profile
list_domainsआपके link domains, default और उनकी ids।domains:read
get_qr_imagePNG जिसे assistant दिखा या सेव कर सकता है, साथ ही प्रिंट के लिए SVG URL।codes:read
get_accountAccount का plan, features और limits।profile

यह सुरक्षित कैसे रहता है

  • Assistant के पास केवल आपके account का token होता है, जो आपके QRFLOW page पर Allow दबाने के बाद जारी किया जाता है। Account › Connected apps पर इसे कभी भी disconnect करें।
  • Tokens MCP server से बँधे होते हैं; उन्हें REST API पर दोबारा इस्तेमाल नहीं किया जा सकता।
  • हर write पर dashboard जैसे ही validation लागू होता है: allow-listed destinations, plan checks और उचित उपयोग की सीमाएँ।
  • विनाशकारी tools अपने काम का सावधानी से वर्णन करते हैं: delete_qr_code model को निर्देश देता है कि प्रिंट मौजूद होने पर code को रोकना बेहतर है।
  • Discovery documents /.well-known/oauth-authorization-server और /.well-known/oauth-protected-resource पर उपलब्ध हैं; registration RFC 7591 है; केवल PKCE S256।

SDKs और OpenAPI spec

  • TypeScript / JavaScript: npm install qrflow (npm)। कोई निर्भरता नहीं, ESM और CommonJS, पूर्ण टाइपिंग; Node 18+, Bun, Deno और Workers में चलता है। 429 त्रुटियों पर अपने-आप फिर कोशिश करता है और verifyWebhook / parseWebhook उपलब्ध कराता है।
  • Python 3.9+, केवल मानक लाइब्रेरी: qrflow.py।
  • OpenAPI 3.1: /api/v1/openapi.json। इसे Postman या Insomnia में इंपोर्ट करें, किसी भी भाषा में क्लाइंट जनरेट करें, या ChatGPT Action से जोड़ें।
  • दोनों क्लाइंट टाइप वाला एरर (QRFlowError के साथ status, code, message, retryAfter) देते हैं और webhook verifier उपलब्ध कराते हैं। अगर आप इसे अपने कोड में शामिल करना चाहें, तो TypeScript का सिंगल-फ़ाइल सोर्स अब भी /sdk/qrflow.ts पर है।
TypeScriptPythonCalls
me()me()GET /me
catalog()catalog()GET /catalog
listCodes({ limit, q })list_codes(limit, q)GET /codes
getCode(id)get_code(id)GET /codes/:id
createCode(input)create_code(**fields)POST /codes
updateCode(id, patch)update_code(id, **patch)PATCH /codes/:id
deleteCode(id)delete_code(id)DELETE /codes/:id
makeDynamic(id)make_dynamic(id)POST /codes/:id/dynamic
scans(id, { from, to, group })scans(id, from_, to, group)GET /codes/:id/scans
bulkCreate(rows, colors)bulk_create(rows, **colors)POST /codes/bulk
domains()domains()GET /domains
listWebhooks() / createWebhook() / testWebhook(id) / deleteWebhook(id)list_webhooks() / create_webhook() / test_webhook(id) / delete_webhook(id)/webhooks
imageUrl(id, size)image_url(id, size)इमेज का पता (इसे key के साथ fetch करें)
verifyWebhook(raw, header, secret)verify_webhook(raw, header, secret)डिलीवरी के लिए हस्ताक्षर की जाँच

Endpoint संदर्भ

Base URL https://qrflow.codes/api/v1। अनुरोध बॉडी और प्रतिक्रियाएँ JSON हैं। तारीखें UTC में ISO 8601 फ़ॉर्मैट में हैं। PATCH में केवल बदलने वाले फ़ील्ड भेजें।

GETprofile

इस खाते पर लागू प्लान, फ़ीचर फ़्लैग और सीमाएँ, साथ ही key के scopes।

curl https://qrflow.codes/api/v1/me \
  -H "Authorization: Bearer $QRFLOW_KEY"
{ "id": "…", "email": "ops@example.com", "plan": "business", "paid": true,
  "features": { "dynamic_codes": true, "custom_domain": true, "link_names": true, "gs1": true, "api_keys": true },
  "limits": { "saved_codes": 25000, "bulk_per_month": 10000, "bulk_per_request": 2000, "link_domains": 5, "requests_per_minute": 600 },
  "auth": "api_key", "scopes": ["codes:read", "codes:write"] }

GETpublic

नेटिव प्रकार (url, wifi, vcard, email, phone, sms, text, location) और लगभग 50 उपप्रकार (Instagram, Google review, Wi-Fi, app store…), हर एक के लिए ज़रूरी फ़ील्ड और आवश्यक प्लान सहित। Key की ज़रूरत नहीं।

curl https://qrflow.codes/api/v1/catalog

GETcodes:read

नवीनतम पहले।?limit= अधिकतम 100 तक;?q= लेबल खोजता है।

curl "https://qrflow.codes/api/v1/codes?limit=20&q=menu" \
  -H "Authorization: Bearer $QRFLOW_KEY"

POSTcodes:write

साइट पर Save के समान नियम: url, phone, email, sms और location कोड सशुल्क प्लान पर डायनामिक होते हैं; Wi-Fi, vCard और text अपनी सामग्री pattern में रखते हैं। उदाहरण के लिए, Google review कोड बनाने के लिए destination_data.subtype में subtype id डालें। वैकल्पिक domain_id चुनता है कि कोड आपके किस link domain के साथ प्रिंट होगा (GET /domains उन्हें सूचीबद्ध करता है)।

curl -X POST https://qrflow.codes/api/v1/codes \
  -H "Authorization: Bearer $QRFLOW_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "type": "url", "destination_data": { "url": "https://example.com/menu" }, "label": "Table tents", "frame_style": "caption-below", "frame_caption": "Scan for menu" }'
{ "code": { "id": "…", "label": "Table tents", "kind": "url", "dynamic": true, "short_code": "x7k2p9a",
  "short_url": "https://go.example.com/x7k2p9a", "scans": 0, "image_url": "https://qrflow.codes/api/v1/codes/…/image.svg", … } }

GETcodes:read

कोड, उसकी scan संख्या, short link और image address सहित।

curl https://qrflow.codes/api/v1/codes/$ID \
  -H "Authorization: Bearer $QRFLOW_KEY"

PATCHcodes:write

इनमें से कोई भी: destination_data (केवल डायनामिक कोड; प्रिंट वैध रहता है), label, paused, expires_at (ISO या null), slug (आपके domain पर link का नाम), domain_id (आपके किस link domain के साथ यह कोड प्रिंट होगा; null = खाते का डिफ़ॉल्ट), fg_color, bg_color, frame_style, frame_caption, frame_caption2। केवल वे फ़ील्ड भेजें जिन्हें आप बदल रहे हैं।

curl -X PATCH https://qrflow.codes/api/v1/codes/$ID \
  -H "Authorization: Bearer $QRFLOW_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "destination_data": { "url": "https://example.com/menu-fall" }, "slug": "menu" }'

DELETEcodes:write

हमेशा के लिए हट जाता है, scan इतिहास सहित। डायनामिक कोड का प्रिंट किया हुआ link काम करना बंद कर देता है। अगर प्रिंट अब भी मौजूद है, तो paused: true को प्राथमिकता दें।

curl -X DELETE https://qrflow.codes/api/v1/codes/$ID \
  -H "Authorization: Bearer $QRFLOW_KEY"
204 No Content

POSTcodes:write

प्रिंट किया हुआ pattern बदल जाता है (अब यह short link encode करता है), इसलिए बाद में इमेज फिर से रेंडर करें।

curl -X POST https://qrflow.codes/api/v1/codes/$ID/dynamic \
  -H "Authorization: Bearer $QRFLOW_KEY"

GETcodes:read

फ़्रेम और रंगों सहित, प्रिंट के लिए तैयार SVG।?size= मॉड्यूल ग्रिड की चौड़ाई px में तय करता है; फ़ाइल वैसे भी बिना गुणवत्ता खोए स्केल होती है।

curl https://qrflow.codes/api/v1/codes/$ID/image.svg \
  -H "Authorization: Bearer $QRFLOW_KEY" -o code.svg

GETanalytics:read

?from= और?to= (ISO तारीखें, अधिकतम 92 दिन; डिफ़ॉल्ट पिछले 30 दिन) और?group= day, device, country, city, browser, os या referrer। वही आँकड़े जो analytics पेज पर हैं।

curl "https://qrflow.codes/api/v1/codes/$ID/scans?from=2026-09-01&to=2026-09-21&group=day" \
  -H "Authorization: Bearer $QRFLOW_KEY"
{ "code_id": "…", "from": "…", "to": "…", "group": "day", "total": 412,
  "rows": [ { "key": "2026-09-01", "scans": 18 }, { "key": "2026-09-02", "scans": 25 }, … ] }

POSTcodes:write

एक कॉल में अधिकतम 2,000 URL कोड, सभी डायनामिक। यह Bulk पेज के समान मासिक bulk allowance में गिने जाते हैं (Business पर 10,000)। जो पंक्तियाँ वेब पते नहीं हैं, वे rejected में लौटती हैं; बाकी बनाई जाती हैं।

curl -X POST https://qrflow.codes/api/v1/codes/bulk \
  -H "Authorization: Bearer $QRFLOW_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "rows": [ { "destination": "https://example.com/t/1", "label": "Table 1" }, { "destination": "https://example.com/t/2", "label": "Table 2" } ] }'
{ "codes": [ … ], "rejected": [], "remaining_this_month": 9998 }

GETcodes:read

वे कोड जो खुदरा पैकेजिंग पर लगाए जाते हैं। हर उत्पाद में एक GTIN, पैक पर प्रिंट किया गया पता और उसके पीछे के links होते हैं। नाम और GTIN खोजने के लिए?q= का उपयोग करें। Business प्लान।

curl https://qrflow.codes/api/v1/products \
  -H "Authorization: Bearer $QRFLOW_KEY"
{ "products": [ { "gtin": "00860001234565", "name": "Wildflower Honey 12 oz",
    "digital_link": "https://id.example.com/01/00860001234565",
    "page_url": "https://id.example.com/p/00860001234565",
    "links": [ { "link_type": "gs1:pip", "url": "…", "is_default": true, "batch": null } ] } ] }

POSTcodes:write

gtin और name आवश्यक हैं; brand और url वैकल्पिक हैं। कुछ भी लिखे जाने से पहले check digit सत्यापित किया जाता है, और 8, 12, 13 तथा 14 अंकों वाले फ़ॉर्म 14 अंकों में सामान्यीकृत होते हैं। आपके पास पहले से मौजूद GTIN के लिए दूसरा उत्पाद बनाने के बजाय 409 मिलता है।

curl -X POST https://qrflow.codes/api/v1/products \
  -H "Authorization: Bearer $QRFLOW_KEY" -H "Content-Type: application/json" \
  -d '{"gtin":"00860001234565","name":"Wildflower Honey 12 oz","brand":"Sunny Acres","url":"https://sunnyacres.example/honey"}'
{ "product": { "gtin": "00860001234565", "digital_link": "https://id.example.com/01/00860001234565", … } }

PUTcodes:write

एक GTIN एक साथ कई जगहों पर ले जा सकता है, और हर जगह को उसके उद्देश्य के अनुसार लेबल किया जा सकता है। फ़ोन को डिफ़ॉल्ट मिलता है; किसी प्रकार का अनुरोध करने वाले ऐप को वही प्रकार मिलता है। यह idempotent है: वही link_type और batch उस link को जोड़ने के बजाय बदल देते हैं, इसलिए रात में चलने वाली स्क्रिप्ट दो बार चल सकती है। Link को एक lot तक सीमित करने के लिए batch दें; इससे बाकी उत्पादन को प्रभावित किए बिना recall प्रकाशित किया जा सकता है।

curl -X PUT https://qrflow.codes/api/v1/products/00860001234565/links \
  -H "Authorization: Bearer $QRFLOW_KEY" -H "Content-Type: application/json" \
  -d '{"link_type":"gs1:recallStatus","url":"https://sunnyacres.example/recall-a42","title":"Recall notice","batch":"A42","is_default":true}'

GETanalytics:read

पिछले?days= (1 से 365, डिफ़ॉल्ट 30) दिनों के लिए हर GTIN के अनुसार गिनती, country, device, link type और batch के आधार पर विभाजित। went_nowhere उन scans की गिनती करता है जिन्हें कोई destination नहीं मिला; यह शून्य होना चाहिए।

curl "https://qrflow.codes/api/v1/products/00860001234565/scans?days=30" \
  -H "Authorization: Bearer $QRFLOW_KEY"
{ "gtin": "00860001234565", "days": 30, "total": 412, "went_nowhere": 0,
  "by_link_type": [ { "key": "gs1:pip", "scans": 390 }, { "key": "gs1:recallStatus", "scans": 22 } ],
  "by_batch": [ { "key": "A42", "scans": 22 } ] }

GETdomains:read

आपके जुड़े हुए domains, उनकी स्थिति और वह domain जिसके साथ डायनामिक कोड डिफ़ॉल्ट रूप से प्रिंट होते हैं (default_base)। किसी कोड को दूसरे domain के साथ प्रिंट करने के लिए domain_id में उस domain की id दें।

curl https://qrflow.codes/api/v1/domains \
  -H "Authorization: Bearer $QRFLOW_KEY"

GETwebhooks:manage

आपके webhooks, उनके events, पिछली स्थिति और विफलताओं की संख्या सहित।

curl https://qrflow.codes/api/v1/webhooks \
  -H "Authorization: Bearer $QRFLOW_KEY"

POSTwebhooks:manage

url किसी सार्वजनिक host पर https होना चाहिए; events में scan, code.created, code.updated, code.deleted में से कोई भी हो सकता है। Signing secret केवल एक बार लौटाया जाता है।

curl -X POST https://qrflow.codes/api/v1/webhooks \
  -H "Authorization: Bearer $QRFLOW_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "url": "https://example.com/hooks/qrflow", "events": ["scan", "code.updated"] }'
{ "webhook": { "id": "…", "url": "…", "events": ["scan", "code.updated"], "active": true, "secret": "whsec_…" } }

POSTwebhooks:manage

अभी हस्ताक्षरित ping भेजता है और प्रतिक्रिया की रिपोर्ट देता है।

curl -X POST https://qrflow.codes/api/v1/webhooks/$WEBHOOK_ID \
  -H "Authorization: Bearer $QRFLOW_KEY"

DELETEwebhooks:manage

कतार में मौजूद retries सहित, सभी deliveries रोकता है।

curl -X DELETE https://qrflow.codes/api/v1/webhooks/$WEBHOOK_ID \
  -H "Authorization: Bearer $QRFLOW_KEY"
204 No Content

GETpublic

Frame ids और हर एक के लिए आवश्यक चीज़ें (caption, दूसरी पंक्ति), customizer की तरह समूहित। Key की ज़रूरत नहीं।

curl https://qrflow.codes/api/v1/frames

Code ऑब्जेक्ट

कोड से संबंधित हर endpoint एक ही संरचना लौटाता है। जिन फ़ील्ड को आप नहीं पहचानते, उन्हें अनदेखा करें; समय के साथ नए फ़ील्ड जोड़े जाते हैं।

FieldTypeMeaning
iduuidस्थायी id। हर दूसरी कॉल में इसका उपयोग करें।
labelstring | nullडैशबोर्ड में नाम। अधिकतम 120 अक्षर।?q= से खोजा जा सकता है।
kindstringकैटलॉग id: url, wifi, instagram, googlereview,... kind_label इसका मानव-पठनीय नाम है।
typestringएन्कोडिंग: url, text, wifi, vcard, email, phone, sms, location।
destination_dataobjectआपके भेजे हुए फ़ील्ड (साथ में kinds के लिए subtype)। destination इसका एक-पंक्ति सारांश है।
dynamicbooleanTrue होने पर scans QRFLOW से होकर जाते हैं और destination बदला जा सकता है। dynamic_capable बताता है कि सशुल्क प्लान पर यह प्रकार डायनामिक हो सकता है या नहीं।
short_codestringसात अक्षर, कभी नहीं बदलता।
short_urlstringडायनामिक कोड के लिए प्रिंट किया जाने वाला पता। सेट होने पर इसमें आपका domain और slug शामिल होते हैं।
domain_iduuid | nullवह link domain जिसके साथ यह कोड प्रिंट होता है; null का अर्थ है खाते का डिफ़ॉल्ट।
fg_color, bg_colorhexमॉड्यूल और बैकग्राउंड के रंग।
has_logobooleanडैशबोर्ड में लोगो जोड़ा गया था; image.svg में यह शामिल है।
frame_style, frame_caption, frame_caption2string | nullFrame id और captions, customizer के अनुसार।
scansintegerकुल scan संख्या।
created_at, updated_atISO 8601UTC।
manage_urlurlडैशबोर्ड में कोड का पेज, 'Open in QRFLOW' लिंक के लिए।
image_urlurlGET /codes/:id/image.svg। Authorization header आवश्यक; यह सार्वजनिक image URL नहीं है।
svg_download_url, png_download_urlurlवही SVG (frame, रंग, logo सहित) और एक सादा PNG, हस्ताक्षरित links के ज़रिए जो 24 घंटे तक बिना header के काम करते हैं: <img> tags, scripts और फ़ाइल सहेजने वाले assistants के लिए। download_expires_at बताता है कि वे कब समाप्त होंगे; कोड पढ़ने पर हर बार नए links मिलते हैं।

अन्य संरचनाएँ: Scans (code_id, from, to, group, total, rows[key, scans]), Domain (id, host, status, active, is_default, verified_at, grace_until), Webhook (id, url, events, active, last_status, last_delivery_at, consecutive_failures, साथ में secret एक बार), Me (id, email, plan, paid, features, limits, auth, scopes) और Error (error, message)। OpenAPI दस्तावेज़ में हर property का type दिया गया है।

Business

Webhooks

कुछ होने पर QRFLOW आपके https URL को कॉल करता है। Account › Webhooks पर या POST /webhooks से webhook बनाएँ; signing secret आपको केवल एक बार मिलता है। हर खाते में अधिकतम 10।

EventWhendata
scanबैच में: हर कुछ मिनट पर, पिछली delivery के बाद के सभी नए scans, हर कॉल में अधिकतम 500।count, from, to, scans[] में code_id, label, short_code, slug, scanned_at, device, country, city, referrer, browser, os, language
code.createdAPI और assistants से तुरंत; डैशबोर्ड से कुछ मिनटों के भीतर। Bulk अनुरोध एक event भेजता है, जिसमें bulk: true और codes[] होते हैं।code, source
code.updatedयही समय-सीमा। इसमें destination, label, pause, expiry, link name, domain, colors, frame और डायनामिक में रूपांतरण शामिल हैं।code, changed[] (बदले गए फ़ील्ड के नाम)
code.deletedयही समय-सीमा।code: { id, label, short_code, slug }
pingजब आप Test दबाते हैं।webhook_id, message

क्या प्राप्त होता है

हर payload { id, event, created_at, data } होता है। id एक delivery के retries में स्थिर रहता है, इसलिए आप इसके आधार पर डुप्लिकेट पहचान सकते हैं।

{
  "id": "9b1c6d2e-…",
  "event": "scan",
  "created_at": "2026-09-21T18:05:00.000Z",
  "data": {
    "count": 2,
    "from": "2026-09-21T18:00:00.000Z",
    "to": "2026-09-21T18:04:12.331Z",
    "scans": [
      { "code_id": "…", "label": "Table tents", "short_code": "x7k2p9a", "slug": "menu", "scanned_at": "2026-09-21T18:03:40.101Z",
        "device": "mobile", "country": "US", "city": "Las Vegas", "referrer": null, "browser": "Safari", "os": "iOS", "language": "en-US" },
      { "code_id": "…", "label": "Table tents", "short_code": "x7k2p9a", "slug": "menu", "scanned_at": "2026-09-21T18:04:12.331Z",
        "device": "mobile", "country": "MX", "city": "Tijuana", "referrer": null, "browser": "Chrome", "os": "Android", "language": "es-MX" }
    ]
  }
}
{
  "id": "2f0a…",
  "event": "code.updated",
  "created_at": "2026-09-21T18:06:00.000Z",
  "data": {
    "code": { "id": "…", "label": "Table tents", "kind": "url", "dynamic": true, "short_url": "https://go.example.com/menu", "scans": 412, "…": "…" },
    "changed": ["destination_data"]
  }
}
POST /your/endpoint HTTP/1.1
Content-Type: application/json
User-Agent: QRFLOW-Webhooks/1.0 (+https://qrflow.codes/developers)
X-QRFLOW-Event: scan
X-QRFLOW-Signature: t=1758477900,v1=5f1c…e9

हस्ताक्षर सत्यापित करें

X-QRFLOW-Signature: t=<unix seconds>,v1=<hex>। अपने secret के साथ ${t}.${rawBody} पर HMAC-SHA256 की गणना करें और v1 से constant time में तुलना करें; अगर t पाँच मिनट से अधिक पुराना हो, तो अनुरोध अस्वीकार करें। प्राप्त किए गए raw bytes का उपयोग करें, कभी भी दोबारा serialize किए गए object का नहीं। Next.js और Python के लिए काम करने वाले receivers recipes में हैं, और दोनों SDKs में helper शामिल है।

Delivery के नियम

  • 8 सेकंड के भीतर किसी भी 2xx का जवाब दें। जवाब देने के बाद काम करें।
  • अन्य सभी प्रतिक्रियाओं पर 1, 5, 15, 60, 240 और 720 मिनट बाद फिर कोशिश की जाती है।
  • लगातार बीस विफलताओं पर webhook बंद हो जाता है और खाते के मालिक को ईमेल भेजा जाता है। Receiver ठीक होने पर इसे फिर चालू करें; कतार में मौजूद retries फिर शुरू हो जाएँगे।
  • URLs किसी सार्वजनिक host पर https होने चाहिए। localhost, निजी ranges और qrflow.codes को अस्वीकार किया जाता है। डेवलपमेंट के दौरान tunnel का उपयोग करें।
  • हस्ताक्षरित ping पाने और अपने सर्वर की प्रतिक्रिया की स्थिति देखने के लिए Test दबाएँ।

त्रुटियाँ

हर त्रुटि { "error": "<code>", "message": "<what to do>" } होती है और नीचे दी गई स्थिति के साथ आती है। संदेश उपयोगकर्ता के लिए लिखा गया है; उसे दिखाएँ।

StatuserrorMeaning

लक्षण, कारण, समाधान

समस्या निवारण

हर कॉल पर 401 invalid_token

कारणHeader गलत है या key सक्रिय नहीं है।

समाधानठीक यही भेजें: Authorization: Bearer qrf_live_… (कोलन नहीं, एक space)। जाँचें कि Account › API keys पर key रद्द तो नहीं की गई। अगर आपने इसे किसी chat या दस्तावेज़ से कॉपी किया है, तो अंत में लगे full stop या smart quote पर ध्यान दें।

ऐसे token के साथ /api/v1 पर 401 जो MCP server पर काम करता है

कारणhttps://qrflow.codes/mcp के लिए जारी किए गए tokens उसी से बँधे होते हैं।

समाधानREST के लिए API key का उपयोग करें, या REST API के लिए token पाने हेतु resource= के बिना दूसरा OAuth flow चलाएँ।

Key या webhook बनाते समय 402 upgrade_required

कारणदोनों Business सुविधाएँ हैं।

समाधान/pricing पर अपग्रेड करें, या MCP server का उपयोग करें, जो sign-in के ज़रिए हर प्लान पर काम करता है।

OAuth app से POST /codes पर 402

कारणउपयोगकर्ता के प्लान में ऐप द्वारा माँगी गई सुविधा (डायनामिक कोड, domain) शामिल नहीं है।

समाधानपहले GET /me features पढ़ें और उसके अनुसार काम करें: कोड फिर भी बनाएँ (Free पर यह static होगा) या उपयोगकर्ता को बताएँ कि इसके लिए किस प्लान की ज़रूरत है।

403 insufficient_scope

कारणKey बनाते समय scopes तय होते हैं। Fixआपको जिन scopes की ज़रूरत है, उनके साथ एक नई key बनाएँ और पुरानी key रद्द करें। OAuth के लिए, authorize request में scope माँगें।

400 not_dynamic when I PATCH destination_data

Whyकोड static है: Wi-Fi/vCard/text प्रकार का, या Free पर बनाया गया ऐसा कोड जिसमें एक मुफ़्त dynamic कोड पहले ही इस्तेमाल किया जा चुका हो।

Fixurl/phone/email/sms/location के लिए, जब खाते में allowance हो, POST /codes/:id/dynamic करें, फिर दोबारा डाउनलोड करके फिर से प्रिंट करें (चित्र बदल जाता है)। Wi-Fi, vCard और text कभी dynamic नहीं हो सकते; इसके बजाय ऐसा url कोड बनाएँ जो कोई पेज खोले।

400 no_domain when I set slug

WhyLink नाम आपके domain पर होते हैं।

Fixपहले Account पेज पर domain कनेक्ट और verify करें। qrflow.codes/q पर path हमेशा short_code होता है।

409 conflict on slug

Whyआपके किसी दूसरे कोड का नाम वही है।

Fixउसे खोजने के लिए GET /codes?q= करें, या कोई दूसरा नाम चुनें। नाम प्रति खाते के हिसाब से होते हैं, global नहीं।

CORS error in the browser console

WhyAPI केवल server-to-server कॉल (और Canva) स्वीकार करता है। यह जानबूझकर ऐसा है: वेब पेज में रखी key लीक हो चुकी key होती है।

Fixकॉल को route handler, server action, edge function या backend में ले जाएँ और पेज से वहीं कॉल करें।

The image shows a QRFLOW mark

Whyकोड ऐसे व्यक्ति ने बनाया था जिसने sign in नहीं किया था। यह mark केवल anonymous downloads के लिए है।

Fixकोई भी खाता इसे हटा देता है, मुफ़्त खाता भी। सहेजे गए कोड की छवियों पर यह कभी नहीं होता।

short_url still says qrflow.codes/q/… after I added my domain

WhyDomain अभी verify नहीं हुआ है, या उसका CNAME गलत है।

FixAccount पेज पर status या GET /domains देखें (status verified होना चाहिए)। Verify होते ही मौजूदा कोड अपने-आप बदल जाते हैं।

image_url gives 401 in an <img> tag

Whyइसके लिए Authorization header चाहिए, जिसे <img> नहीं भेज सकता।

Fixउसी Code object से svg_download_url या png_download_url इस्तेमाल करें: ये signed links बिना header के 24 घंटे तक काम करते हैं। स्थायी समाधान के लिए, image_url को अपने server के ज़रिए proxy करें (Next.js recipe देखें) या short_url को खुद encode करें।

I need a PNG, not an SVG

WhySVG में frame और logo होते हैं; PNG सादा कोड होता है।

FixGET /codes/:id/image.png (bearer या signed png_download_url) 256 से 2048 px तक का PNG देता है। Frame वाला PNG पाने के लिए, SVG को sharp या resvg से convert करें (sharp(svgBuffer).png().toBuffer())।

My assistant said the image endpoint refused it and drew the code itself

Whyउसने image_url fetch किया, जिसके लिए bearer चाहिए।

Fixअब हर कोड में png_download_url और svg_download_url होते हैं, और get_qr_image इन्हें लौटाता है; assistant बिना sign-in के इन्हें curl कर सकता है। ऐसा कोड जिसे स्थानीय रूप से बनाया गया हो और जो वही short_url encode करता हो, फिर भी काम करता है और scans गिनता है, लेकिन उसमें frame और logo नहीं होते।

Webhook never arrives

WhyURL के नियम या receiver।

FixURL किसी public host पर https होना चाहिए (localhost, private IPs या qrflow.codes नहीं)। Webhook पर Test दबाएँ: परिणाम में आपके server द्वारा लौटाया गया status दिखता है। Scan events को batch किया जाता है और आने में लगभग पाँच मिनट तक लग सकते हैं; dashboard के code.* events भी कुछ मिनटों के लिए queue में रहते हैं, जबकि API और MCP writes तुरंत deliver होते हैं।

Signature never verifies

Whyआपने दोबारा serialize किए गए body पर हस्ताक्षर किए।

FixJSON parsing से पहले, आपको मिले सटीक raw bytes के आधार पर verify करें। Express में उस route पर express.raw({ type: 'application/json' }) इस्तेमाल करें; Next.js App Router में await req.text(); Flask में request.get_data() इस्तेमाल करें। फिर ${t}.${raw}\ का HMAC-SHA256 निकालें।

Webhook switched itself off

Whyलगातार बीस बार विफलता।

FixReceiver ठीक करें, फिर उसे दोबारा active करें (Account › Webhooks, या delete करके फिर से बनाएँ)। ऐसा होने पर आपको ईमेल भेजा गया था। Queue में रखे retries फिर से शुरू हो जाएँगे।

Duplicate webhook deliveries

Whyधीमे 2xx (8 सेकंड से ज़्यादा) को विफलता माना जाता है और फिर से कोशिश की जाती है।

Fixपहले जवाब दें, फिर process करें। Payload के id के आधार पर duplicates हटाएँ; retries में यह स्थिर रहता है।

429 rate_limited during an import

Whyप्रति key प्रति मिनट 600 requests।

Fixहर कोड के लिए एक POST करने के बजाय POST /codes/bulk (एक request में 2,000 codes) इस्तेमाल करें, या Retry-After सेकंड तक रुकें।

I deleted a code and the printed poster now shows 'Code not found'

WhyDelete स्थायी है और link को निष्क्रिय कर देता है।

Fixइसे वापस नहीं लिया जा सकता। अगली बार PATCH { paused: true } करें; paused कोड एक उपयोगी पेज दिखाता है और फिर से शुरू किया जा सकता है।

My key stopped working after I downgraded

WhyBusiness छोड़ने के बाद keys 30 दिनों तक काम करती रहती हैं, फिर 402 का जवाब देती हैं।

Fixदोबारा subscribe करें; कुछ भी delete नहीं हुआ था और वही keys फिर से काम करेंगी।

सूची में आपकी समस्या नहीं है? hello@qrflow.codes पर सटीक request और आपको मिला JSON error भेजें। Business खातों को प्राथमिकता मिलती है।

सीमाएँ और उचित उपयोग

सीमा
प्रति key, प्रति मिनट requests600. इससे अधिक पर Retry-After के साथ 429।
प्रति खाते keys10
प्रति खाते webhooks10
सहेजे गए codes (उचित उपयोग)1,000 Premium, 25,000 Business; API इसकी दोगुनी संख्या पर रुक जाता है।
BulkPremium में 500/महीना (प्रति request 500); Business में 10,000/महीना (प्रति request 2,000)।
Link domains1 Premium, 5 Business
Scansअसीमित। Premium में प्रति code प्रति माह 100,000 scans पर और Business में 1,000,000 पर जाँच के लिए ईमेल; किसी चीज़ पर throttling नहीं होती।
Scan analytics windowप्रति request 92 दिन
List page size100 (?limit=)
Label / captions / slug120 / 60 / 40 अक्षर
Webhook timeout और retries8 सेकंड; 1, 5, 15, 60, 240 और 720 मिनट बाद retries; लगातार 20 विफलताओं के बाद बंद।
Business छोड़ने के बादKeys और webhooks 30 दिनों तक काम करते हैं, फिर 402। कुछ भी delete नहीं होता।

उचित उपयोग वही है जिसके लिए plan की कीमत तय की गई है। उस संख्या पर throttling नहीं होती; API उसकी दोगुनी संख्या पर रुक जाता है और पहले कोई व्यक्ति आपको ईमेल करता है। अधिक मात्रा के लिए: hello@qrflow.codes।

सुरक्षा, आपके लिए और scan करने वाले लोगों के लिए

QRFLOW आपके खाते की सुरक्षा कैसे करता है

  • Keys केवल एक बार दिखाई जाती हैं और SHA-256 hashes के रूप में संग्रहीत होती हैं। QRFLOW में कोई भी key को वापस पढ़ नहीं सकता; अगर आप उसे खो दें, तो नई बनाएँ।
  • हर request उस खाते तक सीमित होती है जिससे key जुड़ी है। किसी दूसरे खाते का code id 404 देता है, कभी लीक नहीं होता।
  • हर key के scopes तय होते हैं, इसलिए reporting dashboard की key codes बना या delete नहीं कर सकती।
  • प्रति key प्रति मिनट 600 requests; इससे अधिक पर साफ़ 429 मिलता है, सभी के लिए धीमापन नहीं।
  • Destinations की allow-list होती है: http, https, mailto, tel, sms, geo और app schemes की एक छोटी सूची (whatsapp, tg, signal, spotify, app stores)। javascript:, data: और file: को create करते समय अस्वीकार कर दिया जाता है, ताकि compromised integration आपके codes को हमले का ज़रिया न बना सके।
  • Webhook URLs public hosts पर https होने चाहिए; QRFLOW कभी private networks या खुद को call नहीं करता। हर delivery पर हस्ताक्षर किए जाते हैं और हर payload का एक स्थिर id होता है।
  • OAuth clients को PKCE S256 के साथ register किया जाता है और tokens उसी server से बँधे होते हैं जिसके लिए वे जारी किए गए थे; MCP server का token REST API पर दोबारा इस्तेमाल नहीं किया जा सकता।
  • कोई भी Account पेज पर key रद्द कर सकता है या app disconnect कर सकता है; इसका असर तुरंत होता है।

आपको अपनी ओर से क्या करना चाहिए

  • Environment variables इस्तेमाल करें, source code नहीं। अगर कोई key git history में आ जाए, तो उसे रद्द करें।
  • केवल server-side पर इस्तेमाल करें। API browser origins को अस्वीकार करता है, लेकिन उसे wrap करने वाले आपके अपने endpoints को भी authentication चाहिए, वरना कोई भी आपके खर्च पर codes बना सकता है।
  • हर integration को उसकी ज़रूरत के scopes वाली अलग key दें और उसका नाम integration के नाम पर रखें। फिर एक key रद्द करने से केवल एक चीज़ प्रभावित होगी।
  • Webhook signatures verify करें और पाँच मिनट से पुराने timestamps अस्वीकार करें।
  • अगर आपके users का data labels या destinations में जाता है, तो याद रखें कि QRFLOW उसे संग्रहीत करता है; जहाँ संभव हो, labels में व्यक्तिगत डेटा न रखें।

Scans क्या रिकॉर्ड करते हैं और क्या नहीं

  • हर redirect में request से निकाले गए device type, country, city, referrer, browser, operating system और language, और code + day + IP + user agent का one-way hash संग्रहीत होता है, ताकि मालिक unique visitors गिन सके। Hash को वापस address में नहीं बदला जा सकता।
  • Scan करने वाले व्यक्ति पर कोई cookies सेट नहीं की जातीं और IP address को scan के साथ संग्रहीत नहीं किया जाता। ज्ञात bots और link-preview crawlers को छोड़ दिया जाता है।
  • Code delete करने से उसके scans delete हो जाते हैं। Account delete करने से सब कुछ delete हो जाता है।
  • पूरा पाठ: https://qrflow.codes/privacy और https://qrflow.codes/terms.

Versioning और स्थिरता

API path में versioned है: /api/v1. v1 के भीतर हम fields, endpoints, kinds और events जोड़ते हैं; हम कुछ हटाते या उसका नाम नहीं बदलते, और responses में अज्ञात fields को आपके code द्वारा अनदेखा किया जाना चाहिए।

अगर कभी v1 में ऐसा बदलाव करना पड़े जो उसे तोड़ता हो, तो वह /api/v2 के रूप में जारी होगा और v1 कम-से-कम बारह महीने तक चलता रहेगा। Deprecations के बारे में key owners को 90 दिन पहले ईमेल किया जाता है।

MCP server अपने tools के लिए भी यही नियम अपनाता है: केवल arguments जोड़े जाते हैं और हर tool का नाम बना रहता है।

/api/v1/openapi.json पर OpenAPI document और /llms-full.txt पर Markdown, API को serve करने वाले code से generate किए जाते हैं, इसलिए वे आज live चीज़ों का वर्णन करते हैं।

डेवलपर्स के आम सवाल

क्या QRFLOW API इस्तेमाल करने के लिए मुझे भुगतान करना होगा?

API keys Business plan के साथ मिलती हैं, जिसकी कीमत $29 प्रति माह है और भुगतान महीने-दर-महीने होता है। MCP server (Claude, ChatGPT, Cursor, Claude Code) और आपके अपने app के लिए OAuth, sign-in के ज़रिए हर plan पर काम करते हैं; वे क्या बना सकते हैं, यह plan पर निर्भर करता है। GET /catalog, GET /frames और /preview.svg के लिए किसी key की ज़रूरत नहीं है।

क्या मैं API के ज़रिए मुफ़्त में QR codes बना सकता हूँ?

Key के साथ नहीं। सादी static image के लिए qrflow.codes पर मुफ़्त generator या कोई भी open-source QR library काम करती है। API dynamic codes, आपका अपना domain, analytics, bulk और webhooks के लिए है—यही paid account में शामिल हैं।

क्या मैं browser से API call कर सकता हूँ?

नहीं। यह browser origins को अस्वीकार करता है, ताकि key कभी web page में न पहुँचे। इसे route handler, server action, edge function या backend से call करें और अपने page से वहाँ call करें।

मुझे कौन-से image formats मिलते हैं?

आपके colors, frame, captions और logo वाला SVG (GET /codes/:id/image.svg, nominal 256 से 4096 px) और सादा PNG (GET /codes/:id/image.png, 256 से 2048 px)। दोनों के लिए bearer चाहिए, या हर Code object में मौजूद signed svg_download_url / png_download_url इस्तेमाल करें, जो बिना header के 24 घंटे काम करते हैं। MCP tool get_qr_image inline PNG और दोनों links लौटाता है।

क्या QR code प्रिंट होने के बाद मैं उसे बदल सकता हूँ?

हाँ, अगर वह dynamic है (paid plan पर url, phone, email, sms, location)। नए destination_data के साथ PATCH /codes/:id करें; चित्र नहीं बदलता, लेकिन अगला scan नई जगह पर जाता है। Wi-Fi, vCard और text codes की सामग्री चित्र में होती है और उन्हें बदला नहीं जा सकता।

short_url और destination में क्या अंतर है?

short_url वह link है जो चित्र के अंदर होता है (go.example.com/menu)। Destination वह जगह है जहाँ वह link redirect करता है (https://example.com/menu-fall)। short_url को एक बार प्रिंट करें और destination को जितनी बार चाहें बदलें।

क्या codes मेरे अपने domain का इस्तेमाल कर सकते हैं?

हाँ। Premium में 1 domain और Business में 5 domains कनेक्ट किए जा सकते हैं; आप CNAME जोड़कर Account पेज पर verify करते हैं। Business में domain_id के ज़रिए हर code के लिए domain चुना जाता है। Link नाम (slug) उस पर पढ़ने योग्य paths बनाते हैं।

Scan करने वाले व्यक्ति के बारे में scan क्या रिकॉर्ड करता है?

Request से device type, country, city, referrer, browser, operating system और language, साथ ही unique-visitor counts के लिए एक one-way daily hash। कोई cookies नहीं और IP address संग्रहीत नहीं होता। Chart के लिए पर्याप्त, किसी की पहचान करने के लिए नहीं। विवरण: https://qrflow.codes/privacy#scans

क्या npm या PyPI package है?

npm: npm install qrflow\ (https://www.npmjs.com/package/qrflow), कोई dependencies नहीं, ESM और CommonJS, पूर्ण TypeScript types, Node 18+, Bun, Deno और Workers पर चलता है; यह हर endpoint को wrap करता है, 429 पर retries करता है और इसमें verifyWebhook/parseWebhook शामिल हैं। Python: https://qrflow.codes/sdk/qrflow.py पर एक single-file client (केवल standard library) जिसमें verify_webhook है; PyPI package बाद में आएगा।

क्या यह Claude, ChatGPT, Cursor और Claude Code के साथ काम करता है?

हाँ। QRFLOW एक MCP server है: https://qrflow.codes/mcp. इसे connector के रूप में जोड़ें, एक बार sign in करें और सामान्य शब्दों में पूछें। ग्यारह tools creating, editing, pausing, naming, bulk, analytics, images और domains को कवर करते हैं।

क्या मेरे अपने users अपने QRFLOW खातों को मेरे app से कनेक्ट कर सकते हैं?

हाँ, OAuth 2.0 के साथ। /api/oauth/register पर क्लाइंट रजिस्टर करें (खाते की ज़रूरत नहीं), PKCE के साथ उपयोगकर्ताओं को /oauth/authorize पर भेजें और उनके टोकन से API कॉल करें। कोड उनके प्लान के तहत उनके खाते में आते हैं।

मैं localhost पर वेबहुक का परीक्षण कैसे करूँ?

अपने डेवलपमेंट सर्वर को टनल (cloudflared या ngrok) से सार्वजनिक करें और उसके https पते को वेबहुक URL के रूप में इस्तेमाल करें। फिर हस्ताक्षरित पिंग पाने के लिए Account › Webhooks पर Test दबाएँ। वेबहुक URL सार्वजनिक https होने चाहिए; localhost और निजी पते अस्वीकार किए जाते हैं।

अगर मैं Business रद्द कर दूँ, तो मेरे इंटीग्रेशन का क्या होगा?

की और वेबहुक 30 दिनों तक काम करते रहेंगे, फिर 402 का जवाब देंगे। कोड, स्कैन और डोमेन खाते में बने रहेंगे। दोबारा सदस्यता लेने पर वही की इस्तेमाल करके सब कुछ फिर से चालू हो जाएगा।

API के ज़रिए Google review, Instagram, Wi-Fi या PDF कोड कैसे बनाऊँ?

GET /catalog हर तरह और उसके फ़ील्ड की सूची देता है। फिर POST /codes में उस तरह का type और फ़ील्ड भेजें, और इन तरहों के लिए subtype जोड़ें: { type: 'url', destination_data: { subtype: 'googlereview', placeId: 'ChIJ…' } }, { type: 'wifi', destination_data: { ssid, password, encryption: 'WPA' } }, { type: 'url', destination_data: { subtype: 'instagram', handle: 'acme' } }।

क्या API किसी कोड पर लोगो अपलोड कर सकती है?

अभी नहीं। डैशबोर्ड में लोगो जोड़ें; image.svg में वह शामिल होता है और has_logo बताता है कि लोगो मौजूद है। रंग, फ़्रेम और कैप्शन—ये सभी API के ज़रिए सेट किए जा सकते हैं।

क्या API स्थिर है?

v1 में केवल चीज़ें जोड़ी जाती हैं; कुछ हटाया या नाम नहीं बदला जाता। कोई ब्रेकिंग बदलाव v2 के रूप में जारी होगा। v1 कम-से-कम बारह महीने तक उपलब्ध रहेगा और ईमेल से 90 दिन पहले सूचना दी जाएगी।

एजेंट, टूल और इसे पढ़ने वाले असिस्टेंट के लिए

मशीन-पठनीय

इस पेज की हर चीज़ ऐसे रूप में उपलब्ध है जिसे सॉफ़्टवेयर फ़ेच कर सकता है। यह सब API को सर्व करने वाले कोड से जनरेट होता है, इसलिए कभी पुराना नहीं पड़ता।

URLयह क्या है
llms-full.txthttps://qrflow.codes/llms-full.txtइस पूरे संदर्भ का Markdown रूप: अवधारणाएँ, हर एंडपॉइंट, हर MCP टूल, रेसिपी, समस्या-निवारण और FAQ। इसी पेज के स्रोत से जनरेट किया गया है।
developers.mdhttps://qrflow.codes/developers.mdयही दस्तावेज़, उन टूल के लिए जो a.md फ़ेच करते हैं।
llms.txthttps://qrflow.codes/llms.txtअसिस्टेंट के लिए साइट इंडेक्स, जो यहाँ निर्देशित करता है।
एक पेज में APIhttps://qrflow.codes/qr-code-apiAPI क्या करती है, क्लाइंट-साइड लाइब्रेरी कब बेहतर विकल्प है और इसकी लागत क्या है। इस संदर्भ का संक्षिप्त रूप, बनाने के बजाय निर्णय लेने के लिए।
openapi.jsonhttps://qrflow.codes/api/v1/openapi.jsonOpenAPI 3.1। Postman, Insomnia, कोड जनरेटर या ChatGPT Action में इंपोर्ट करें।
MCP serverhttps://qrflow.codes/mcpStreamable HTTP, डायनेमिक रजिस्ट्रेशन वाला OAuth या bearer के रूप में Business key।
server.jsonhttps://qrflow.codes/.well-known/mcp/server.jsonMCP रजिस्ट्री मेनिफ़ेस्ट।
OAuth discoveryhttps://qrflow.codes/.well-known/oauth-authorization-serverRFC 8414 मेटाडेटा; protected-resource दस्तावेज़ इसके पास ही है।
npm packagehttps://www.npmjs.com/package/qrflownpm install qrflow। टाइप्ड क्लाइंट, शून्य डिपेंडेंसी और वेबहुक सत्यापन। Python का सिंगल-फ़ाइल क्लाइंट यहाँ है: https://qrflow.codes/sdk/qrflow.py.
GitHubhttps://github.com/nativecodeapps/qrflow-sdkNext.js, Workers, Express, FastAPI और Flask वेबहुक के लिए क्लाइंट, OpenAPI स्नैपशॉट और चलाए जा सकने वाले उदाहरण। Issues और PRs का स्वागत है।

सवाल, सुझाव या कोई ऐसा कोड प्रकार जिसे हमें जोड़ना चाहिए: hello@qrflow.codes। शर्तें: /terms। गोपनीयता: /privacy।