# Verify को Prelude से माइग्रेट करें

यह पेज Prelude के v2 verification API को Bird Verify पर मैप करता है। [मुख्य माइग्रेशन गाइड](/docs/guides/verify/migrate) को क्रम से फ़ॉलो करें और इन मैपिंग्स का उपयोग स्टेप 1 और 3 के लिए करें।

संरचनाएं काफ़ी मिलती-जुलती हैं। Prelude के `POST https://api.prelude.dev/v2/verification` और `POST /v2/verification/check` एक bearer-authenticated create-and-check जोड़ी है जो verification ID के बजाय target पर आधारित है, और [`POST /v1/verify/verifications`](/docs/api/reference/create-verification) तथा [`POST /v1/verify/verifications/check`](/docs/api/reference/create-verification-check) भी ऐसी ही हैं। किसी सक्रिय recipient के लिए create को दोबारा कॉल करना दोनों प्लैटफ़ॉर्म पर नया verification शुरू करने के बजाय फिर से प्रयास करता है। जो पोर्ट नहीं होता वह रिस्क लेयर है: Prelude के signals, routing verdicts, और silent verification का Bird Verify API में कोई समकक्ष नहीं है।

## इसे अपने agent को दें

इसे Claude Code, Cursor, या Codex में पेस्ट करें। agent आपकी रिपॉज़िटरी पर इस पेज के अनुसार काम करता है, जो भी Bird सरफ़ेस उसके पास पहले से है उसका उपयोग करते हुए: MCP सर्वर अगर कनेक्ट है, या CLI अगर इंस्टॉल और साइन इन है।

```text
I am moving a phone verification integration from Prelude to Bird Verify. Route through it with me.
1. Check what you already have before setting anything up. If Bird's MCP server is connected, use its tools. If the Bird CLI is installed and signed in, use that. Either one is enough, and every step below is an action you take with whichever you have. Only if neither is present, follow https://bird.com/docs/ai/set-up-your-agent.md to set one up and sign me in. Every Bird docs page serves Markdown at its own URL with `.md` appended, so fetch that rather than the HTML.
2. Read https://bird.com/docs/guides/verify/migrate/prelude.md for the create, check and status mapping, and https://bird.com/docs/guides/verify/migrate.md for the order the steps go in.
3. Find and list my Prelude usage in this repository before you change anything: the /v2/verification and /v2/verification/check call sites, anywhere I read signals or a routing verdict, and anywhere I use dispatch_id for retry safety.
4. Tell me early which of these I depend on. Bird Verify has no voice channel and no silent or network-based authentication. It generates the code itself and never returns it, so I cannot supply my own. It accepts `options.language` but no per-request template or message body. Bird can use an existing SMS Sender ID or a connected WhatsApp number with an approved authentication template, configured per channel or country rather than per request; tell me whether my current sender can be kept. Prelude's risk layer does not port either: its signals, its routing verdicts and its silent verification have no counterpart in Bird Verify, so tell me every decision my code makes on those.
5. Configure my channels and destinations following https://bird.com/docs/guides/verify/countries.md and https://bird.com/docs/guides/verify/senders.md. While you are there, disable every country I do not actually verify into. An enabled destination I never send to is not reach, it is exposure to SMS pumping, so ask me which countries I serve rather than leaving the defaults.
6. Port the create and check calls using the mapping tables on the provider page, and move my status handling to Bird's events: https://bird.com/docs/guides/verify/sending-verifications.md and https://bird.com/docs/guides/verify/events.md.
7. Cut over at the create call, not all at once, because a code issued by Prelude cannot be checked by Bird and a code issued by Bird cannot be checked by Prelude. From the moment I say go, send every NEW verification to Bird, and keep routing each check to whichever provider issued that verification. Keep both paths live for one full code lifetime plus margin, then retire the old one. Tell me how you will decide which provider issued a given verification before you write any of it.
8. Test before any real traffic. Bird Verify has no simulated recipients, so do not look for a sandbox: the thing worth testing is the code arriving. Run the integration against a phone number and a mailbox I control, on each channel I enabled, and show me what arrived on each one.
9. Stop and ask me wherever a step needs a decision. Do not start routing new verifications to Bird until I have seen those test results and replied with the words cut over to Bird. Retiring the Prelude path is a separate step: ask me again and wait for me to reply with the words retire the Prelude path, and do not retire it while any code it issued could still be checked. A reply that agrees without naming what it is authorising is not authorisation. Finish by telling me what is left that only a person can do.
```

## create कॉल को मैप करें

| यह क्या करता है      | Prelude                                                                          | Bird                                                                                                     |
| -------------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| प्राप्तकर्ता         | `target.type` + `target.value`                                                   | `to.phone_number` या `to.email`                                                                          |
| कोड की लंबाई         | `options.code_size`                                                              | `options.code_length`                                                                                    |
| चैनल प्राथमिकता      | `options.preferred_channel`, `options.channels`                                  | `options.channels`, अन्यथा देश का कॉन्फ़िगर किया गया क्रम                                                |
| कोरिलेशन             | `metadata.correlation_id`                                                        | `metadata`                                                                                               |
| डिलीवरी कॉलबैक       | `options.callback_url`                                                           | एक वर्कस्पेस webhook जो आपके चुने हुए verify इवेंट टाइप से सब्सक्राइब हो                                 |
| कस्टम सत्यापन कोड    | `options.custom_code`                                                            | कोई समकक्ष नहीं                                                                                          |
| लोकलाइज़ेशन          | `options.locale`                                                                 | `options.language`                                                                                       |
| सेंडर पहचान          | `options.sender_id`                                                              | प्रति चैनल या देश के अनुसार Bird-प्रबंधित या वर्कस्पेस-स्वामित्व वाला sender चुनें, प्रति अनुरोध नहीं    |
| मैसेज टेम्पलेट       | `options.template_id`, `options.variables`                                       | कोई प्रति-अनुरोध समकक्ष नहीं; Verify कॉन्फ़िगरेशन में एक अनुमोदित WhatsApp authentication टेम्पलेट चुनें |
| Android ऑटोफ़िल      | `options.app_realm`                                                              | कोई समकक्ष नहीं                                                                                          |
| रिस्क सिग्नल         | `signals` (IP, device, fingerprint)                                              | स्वीकार नहीं किया जाता                                                                                   |
| सुरक्षित पुनः प्रयास | उनके create या check रेफ़रेंस पर कोई idempotency key या हेडर नहीं                | `Idempotency-Key` हेडर                                                                                   |
| Signals कोरिलेशन     | `dispatch_id`, "the identifier of the dispatch that came from the front-end SDK" | कोई समकक्ष नहीं: Bird कोई signals स्वीकार नहीं करता                                                      |
| फ़ॉलबैक नियंत्रण     | `options.max_auto_fallbacks`, `options.force_challenge`                          | देश का चैनल प्लान                                                                                        |

`dispatch_id` फिर से प्रयास करने का तंत्र नहीं है और `Idempotency-Key` के साथ नहीं आता। Prelude का अपना रेफ़रेंस इसे "the identifier of the dispatch that came from the front-end SDK" के रूप में परिभाषित करता है: उनका Signals SDK इसे `dispatchSignals()` से लौटाता है, और आप इसे create पर फ़ॉरवर्ड करते हैं ताकि उनकी फ़्रॉड लेयर ब्राउज़र signals को उस verification से मैच कर सके। उनके create और check रेफ़रेंस पूरे request सेट को बिना idempotency key और बिना कस्टम हेडर के दस्तावेज़ित करते हैं, इसलिए दोबारा किया गया create आपके लिए सुरक्षित नहीं बनाया जाता। Bird पर, [`Idempotency-Key`](/docs/guides/idempotency) हेडर यह काम करता है।

चैनल सेट केवल आंशिक रूप से ओवरलैप करते हैं। Bird email, SMS, WhatsApp, और Telegram पर डिलीवर करता है; Prelude के RCS, Viber, Zalo, voice, और silent चैनल का आज कोई Bird समकक्ष नहीं है। जिस नंबर तक Prelude Viber या Zalo से पहुँचता था, वह यहाँ SMS पर फ़ॉलबैक करता है, जो डिलीवरी-दर का सवाल है और इसे पूर्ण वॉल्यूम पर पता लगाने के बजाय पायलट में मापना बेहतर है।

## check कॉल को मैप करें

दोनों check एंडपॉइंट प्राप्तकर्ता और कोड लेते हैं, कोई verification ID नहीं, इसलिए यह कॉल लगभग जैसी है वैसी ही पोर्ट होती है। अंतर रिस्पॉन्स में है:

| Prelude `status`       | Bird                                             |
| ---------------------- | ------------------------------------------------ |
| `success`              | `success: true`                                  |
| `failure`              | `success: false`, `reason: incorrect_code`       |
| `expired_or_not_found` | `success: false`, `reason: expired`, या एक `404` |
| (कोई सीधा मान नहीं)    | `success: false`, `reason: attempts_exhausted`   |

Prelude "wrong code" और "out of attempts" को `failure` में मिला देता है; Bird इन्हें अलग करता है, और साथ में `attempts_remaining` भी लौटाता है ताकि आप उपयोगकर्ता को बता सकें कि कितने प्रयास बाकी हैं। जो verification पहले ही resolve हो चुका है वह स्टेटस के बजाय `404` लौटाता है, इसलिए दोबारा जाँच करने के बजाय पहला निर्णायक उत्तर स्टोर करें।

## रिस्क लेयर का क्या होता है

Prelude का create रिस्पॉन्स एक routing verdict रिपोर्ट करता है: `status` जो `success`, `retry`, `challenged`, `blocked`, या `shadow_blocked` होता है, अस्वीकृति पर `reason` और `risk_factors` के साथ, और एक `method` जो बताता है कि कौन सा चैनल चुना गया। Bird का create रिस्पॉन्स स्वयं verification है। कोई verdict नहीं है जिस पर ब्रांच करें, कोई signals ऑब्जेक्ट भेजने को नहीं है, और shadow block का कोई समकक्ष नहीं है, इसलिए जो इंटीग्रेशन Prelude के verdict पर साइन-अप गेट करता है उसे Bird कॉल करने से पहले अपना निर्णय लेना होगा।

Bird उस स्पेस से जो लेकर आता है वह सीमित और मुख्यतः कॉन्फ़िगरेशन है: प्रति-देश सक्षमता ताकि जिन गंतव्यों को आप कभी सेवा नहीं देते उन्हें बंद कर सकें, [Abuse guardrails](/docs/guides/verify/sending-verifications#abuse-guardrails) में वर्णित प्लैटफ़ॉर्म send और check कैप्स, और स्वयं चैनल प्लान। अगर pumping सुरक्षा ही Prelude चुनने का कारण था, तो माइग्रेशन शेड्यूल करने से पहले उस अंतर का आकलन करें।

## कॉलबैक माइग्रेट करें

Prelude डिलीवरी स्टेटस को उस `callback_url` पर पोस्ट करता है जो आप प्रति verification सेट करते हैं। Bird आपके वर्कस्पेस द्वारा रजिस्टर किए गए एंडपॉइंट्स पर डिलीवर करता है, प्रत्येक अपने इच्छित इवेंट टाइप्स को सब्सक्राइब करता है, इसलिए URL request body से बाहर चला जाता है। अपने हैंडलर के लिए इवेंट टाइप्स नाम दें: सेशन के लिए `verify.verification.created`, `verify.verification.verified` और `verify.verification.failed`, और प्रत्येक सत्यापन कोड भेजने के लिए `verify.attempt.sent`, `verify.attempt.delivered` और `verify.attempt.undelivered`। इनकी जगह कोई वाइल्डकार्ड नहीं है। [Standard Webhooks](https://www.standardwebhooks.com) के अनुसार सिग्नेचर सत्यापित करें। पेलोड [Verify events](/docs/guides/verify/events) में हैं।

## कटओवर करें

मुख्य गाइड का [कटओवर नियम](/docs/guides/verify/migrate#5-cut-over-one-code-lifetime-at-a-time) यथावत लागू होता है: Prelude द्वारा जारी कोड को Bird से जाँचा नहीं जा सकता, इसलिए create कॉल पर स्विच करें और प्रत्येक check को उस प्रोवाइडर पर रूट करें जिसने वह verification जारी किया था, जब तक कि अंतिम verification एक्सपायर न हो जाए। चूँकि दोनों API प्राप्तकर्ता पर आधारित हैं, ब्रांच आपके मौजूदा कॉल साइट्स के चारों ओर एक सिंगल कंडीशनल है, रीराइट नहीं।

पायलट के दौरान डिलीवरी के साथ-साथ कन्वर्शन पर भी नज़र रखें। Prelude प्रति अनुरोध एक व्यापक चैनल सेट पर रूट करता है; Bird प्रति देश आपके द्वारा सेट किए गए चैनल क्रम पर रूट करता है। अगर किसी बाज़ार का कन्वर्शन गिरता है, तो पोर्ट के बारे में कोई निष्कर्ष निकालने से पहले उस देश के चैनल क्रम को बदलें।

## अगले कदम

- [सत्यापन भेजना](/docs/guides/verify/sending-verifications): दोनों कॉल, स्टेटस, और सीमाओं का पूरा कॉन्ट्रैक्ट
- [देश कॉन्फ़िगरेशन](/docs/guides/verify/countries): प्रति-देश चैनल क्रम और उपलब्धता
- [सेंडर और ब्रांडिंग](/docs/guides/verify/senders): प्राप्तकर्ता को प्रत्येक चैनल पर क्या दिखता है
- [Verify इवेंट्स](/docs/guides/verify/events): वे इवेंट्स जिन पर आपका कॉलबैक कंज़्यूमर माइग्रेट होता है

## Related resources

- [Verify phone numbers at signup](/learn/series/verify-phone-numbers-at-signup) (video)
- [What does OTP mean? One-time passwords explained](/explained/verify/what-does-otp-mean) (answer)
- [Customer verification](/verify-api) (product)
- [Build your first integration](/learn/paths/integration) (course)

[Get an implementation brief](/learn/workspace?topic=verify)