Geocoding API v4 के तरीकों के लिए, डिफ़ॉल्ट कोटा 25 क्वेरी प्रति सेकंड (क्यूपीएस) है. अनुरोध भेजने की सीमा बढ़ाने का अनुरोध करने के बारे में जानकारी पाने के लिए, अनुरोध भेजने की सीमा देखना और मैनेज करना लेख पढ़ें. इसके बाद, सेवा के तौर पर Geocoding API चुनें.

Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

Geocoding v3 से v4 पर माइग्रेट करना

यूरोपियन इकनॉमिक एरिया (ईईए) के डेवलपर

Geocoding API v4 में कई नए तरीके जोड़े गए हैं. ये तरीके, एपीआई के v3 वर्शन में मौजूद सुविधाओं की जगह लेते हैं. इस गाइड में, अपने ऐप्लिकेशन को नए v4 तरीकों का इस्तेमाल करने के लिए माइग्रेट करने का तरीका बताया गया है.

v4 के नए तरीकों के साथ, अपनी मौजूदा एपीआई कुंजियों का इस्तेमाल किया जा सकता है. हालांकि, अगर आपने एपीआई के v3 वर्शन पर कोटा बढ़ाने का अनुरोध किया है, तो आपको नए v4 एपीआई पर भी कोटा बढ़ाने का अनुरोध करना होगा.

चेतावनी: सुरक्षा से जुड़े जोखिमों की वजह से, आपको Geocoding API v4 के तरीकों को सीधे क्लाइंट-साइड JavaScript से कॉल नहीं करना चाहिए. अगर सुझावों के ख़िलाफ़ जाकर ऐसा किया जाता है, तो ध्यान रखें कि ज़्यादा कोटे का अनुरोध करने से, एपीआई पासकोड के गलत इस्तेमाल का असर बढ़ जाता है. क्लाइंट-साइड पर एक्सपोज़ किए गए एपीआई पासकोड का इस्तेमाल करके, Geocoding API v4 को किए जाने वाले सभी कॉल के लिए जोखिम ज़्यादा होता है. ज़्यादा जानकारी के लिए, सुरक्षा से जुड़ी ज़रूरी बातें देखें.

v3 फ़ॉरवर्ड जियोकोडिंग से माइग्रेट करना

अगर पतों को जियोकोड करने के लिए, v3 जियोकोडिंग का इस्तेमाल किया जाता है, तो आपको v4 पते को जियोकोड करें तरीके पर माइग्रेट करना चाहिए. यह तरीका, GET अनुरोध को स्वीकार करता है.

v4 API में कई पैरामीटर के नाम, स्ट्रक्चर, और सहायता में बदलाव किए गए हैं. हमारा सुझाव है कि आप फ़ील्ड मास्क का इस्तेमाल करें, ताकि यह तय किया जा सके कि आपको जवाब में कौनसे फ़ील्ड चाहिए.

अनुरोध के पैरामीटर में बदलाव करना

v3 पैरामीटर	v4 पैरामीटर	नोट
`address`, `components`	`address`	अनस्ट्रक्चर्ड पता (v3 `address`) अब यूआरएल पाथ में पास किया जाता है. स्ट्रक्चर्ड पते के कॉम्पोनेंट (v3 `components`) को `address.*` क्वेरी पैरामीटर के तौर पर पास किया जा सकता है. v3 कॉम्पोनेंट फ़िल्टर फिर से जनरेट करना देखें.
`bounds`	`locationBias.rectangle`	नाम बदला गया; स्ट्रक्चर को ऑब्जेक्ट में बदला गया.
`language`	`languageCode`	नाम बदला गया. अगर v3 में भाषा की जानकारी नहीं दी जाती है, तो यह `Accept-Language` हेडर का इस्तेमाल करता है या डिफ़ॉल्ट रूप से `en` पर सेट हो जाता है. वहीं, v4 डिफ़ॉल्ट रूप से जगह की स्थानीय भाषा और स्क्रिप्ट पर सेट हो जाता है.
`region`	`regionCode`	नाम बदला गया. अगर इसे शामिल नहीं किया जाता है, तो v3 की डिफ़ॉल्ट वैल्यू `us` होती है. वहीं, v4 की कोई डिफ़ॉल्ट वैल्यू नहीं होती है.
`extra_computations`	हटाया गया	इसकी जगह SearchDestinations तरीके का इस्तेमाल किया जाता है.

जवाब वाले फ़ील्ड में बदलाव

v3 फ़ील्ड	v4 फ़ील्ड	नोट
`status`, `error_message`	हटाया गया	v4, एचटीटीपी स्टेटस कोड और गड़बड़ी के मैसेज का इस्तेमाल करता है.
`results.address_components.long_name` / `results.address_components.short_name`	`results.addressComponents.longText` / `results.addressComponents.shortText`	नाम बदला गया.
`results.geometry.location_type`	`results.granularity`	नाम बदला गया.
`results.geometry.location`	`results.location`	फ़ील्ड के नाम: `lat`/`lng` -> `latitude`/`longitude`.
`results.geometry.viewport`	`results.viewport`	फ़ील्ड के नाम: `northeast`/`southwest` -> `high`/`low`.
`results.postcode_localities`	`results.postalCodeLocalities`	नाम बदला गया. अब एक या उससे ज़्यादा इलाकों के लिए नतीजे दिखाए जाते हैं (v3 के लिए, 1 से ज़्यादा नतीजे ज़रूरी हैं).
`results.partial_match`	हटाया गया
नया	`results.addressComponents.languageCode`	पते के किसी कॉम्पोनेंट की भाषा.
नया	`results.bounds`	`high`/`low` का इस्तेमाल करके, साफ़ तौर पर सीमाएं तय की गई हैं.
नया	`results.place`	जगह के लिए संसाधन का नाम.
नया	`results.postalAddress`	स्ट्रक्चर्ड `PostalAddress` ऑब्जेक्ट.

v3 कॉम्पोनेंट फ़िल्टर फिर से बनाना

Geocoding v3 में फ़ॉरवर्ड जियोकोडिंग में एक components पैरामीटर शामिल था. इसकी मदद से, चुनिंदा कॉम्पोनेंट (जैसे, components=country:US) के लिए नतीजों को हार्ड फ़िल्टर किया जा सकता था. v4 में फ़ॉरवर्ड जियोकोडिंग, अनुरोध पैरामीटर में इस तरह के हार्ड फ़िल्टर के साथ काम नहीं करती. v4 में, पते की जानकारी को पाथ में एक अनस्ट्रक्चर्ड स्ट्रिंग के तौर पर या address.addressLines, address.locality, address.administrativeArea, address.postalCode, और address.regionCode जैसे स्ट्रक्चर्ड क्वेरी पैरामीटर के तौर पर दिया जा सकता है. स्ट्रक्चर्ड पैरामीटर, हार्ड फ़िल्टर के तौर पर काम नहीं करते. इसके बजाय, दिए गए सभी कॉम्पोनेंट को मिलाकर पूरा पता बनाया जाता है. एपीआई, इस पते को जियोकोड करने की कोशिश करेगा. एपीआई, सभी कॉम्पोनेंट में दिए गए पूरे पते के लिए सबसे सही मैच खोजता है. स्ट्रक्चर्ड तरीके से कॉम्पोनेंट उपलब्ध कराने से, एपीआई को मकसद को बेहतर तरीके से समझने में मदद मिल सकती है. खास तौर पर, तब जब पते की जानकारी अलग-अलग फ़ॉर्म फ़ील्ड से इकट्ठा की जाती है. इससे एपीआई को हर कॉम्पोनेंट में टाइपिंग की मामूली गलतियों या अस्पष्टताओं को मैनेज करने में मदद मिल सकती है. ऐसा इसलिए, क्योंकि हर फ़ील्ड में जानकारी का टाइप साफ़ तौर पर बताया गया है.

v3 के हार्ड कॉम्पोनेंट फ़िल्टर जैसा व्यवहार पाने के लिए, आपको v4 एपीआई से मिले results कलेक्शन पर क्लाइंट-साइड फ़िल्टर लागू करना होगा. यह फ़िल्टर, रिस्पॉन्स में मौजूद postalAddress और addressComponents ऑब्जेक्ट पर आधारित होता है.

नीचे दी गई टेबल में, v3 components फ़िल्टर और v4 postalAddress फ़ील्ड के बीच सबसे ज़्यादा मिलते-जुलते फ़िल्टर और फ़ील्ड दिखाए गए हैं:

v3 कॉम्पोनेंट फ़िल्टर	v4 रिस्पॉन्स फ़ील्ड
`country`	`postalAddress.regionCode`
`postal_code`	`postalAddress.postalCode`
`administrative_area`	`postalAddress.administrativeArea` या `addressComponents`

क्लाइंट-साइड फ़िल्टर करने के उदाहरण

यहां दिए गए उदाहरणों से पता चलता है कि नतीजों को फ़िल्टर कैसे किया जाता है, ताकि v3 कॉम्पोनेंट फ़िल्टर करने की सुविधा जैसा व्यवहार हासिल किया जा सके. यह सुविधा, इन फ़ील्ड के लिए काम करती है: देश, राज्य, और पिन कोड. हमारा सुझाव है कि अन्य फ़ील्ड पर फ़िल्टर न करें, क्योंकि फ़िल्टर करने के लिए कोई भरोसेमंद शर्त मौजूद नहीं है.

देश के हिसाब से फ़िल्टर करें

अपने अनुरोध में मौजूद address.regionCode को हर नतीजे में मौजूद postalAddress.regionCode से मैच करें. ध्यान दें कि एपीआई, अनुरोध में देश/इलाके के कोड को अंग्रेज़ी के छोटे अक्षरों में स्वीकार करता है. हालांकि, जवाब में वह हमेशा उन्हें अंग्रेज़ी के बड़े अक्षरों में दिखाता है. इसलिए, तुलना करने से पहले आपको अपने इनपुट को अंग्रेज़ी के बड़े अक्षरों में बदलना होगा.

Python कोड का उदाहरण

def filter_by_country(results, region_code):
    return [
        res for res in results
        if res.get('postalAddress', {}).get('regionCode') == region_code.upper()
    ]

# Example usage:
# v4_response = ... # API call response
# filtered = filter_by_country(v4_response.get('results', []), 'US')

Node.js कोड का उदाहरण

function filterByCountry(results, regionCode) {
    return results.filter(res => res.postalAddress?.regionCode === regionCode.toUpperCase());
}

// Example usage:
// const v4Response = ... # API call response
// const filtered = filterByCountry(v4Response.results, 'US');

राज्य के हिसाब से फ़िल्टर करना

अपने अनुरोध में मौजूद address.administrativeArea को हर नतीजे में मौजूद postalAddress.administrativeArea से मैच करें. देश के कोड की तरह ही, तुलना करने से पहले आपको अपने इनपुट को अपरकेस में नॉर्मलाइज़ करना चाहिए. यह सिर्फ़ तब भरोसेमंद होता है, जब आपके अनुरोध में administrativeArea को दो अक्षरों वाले स्टैंडर्ड शॉर्ट फ़ॉर्म के साथ दिया गया हो. जवाब में मौजूद postalAddress.administrativeArea, कई वजहों से ISO 3166-2 कोड के सफ़िक्स से सीधे तौर पर मैच नहीं हो सकता. सबसे पहले, कुछ इलाकों में ISO 3166-2 कोड से जुड़ा सबडिविज़न, डाक पतों के स्टैंडर्ड रिप्रज़ेंटेशन का हिस्सा नहीं होता है. उदाहरण के लिए, स्पेन में, एडमिन लेवल 1 (जैसे, कैनरियास के लिए "CN") addressComponents में मौजूद हो सकता है. हालांकि, postalAddress.administrativeArea में लेवल 2 का इलाका (जैसे, "सांता क्रूज़ डे टेनरीफ़") शामिल हो सकता है. दूसरा, कुछ इलाकों में सबडिवीज़न के नाम के छोटे रूप का इस्तेमाल आम तौर पर नहीं किया जाता. साथ ही, postalAddress.administrativeArea में इसे लंबे नाम के साथ दिखाया जाता है. इसी तरह की वजहों से, सबडिवीज़न के हिसाब से पते के कॉम्पोनेंट के लिए addressComponents.shortText, सबडिवीज़न के ISO 3166-2 कोड के सफ़िक्स से मेल नहीं खा सकता. इसके अलावा, कुछ मामलों में सबडिवीज़न को administrative_area_level_n के लिए पते के कॉम्पोनेंट में दिखाया जा सकता है. इसमें n की वैल्यू 1 से ज़्यादा होती है. सबसे सटीक नतीजे पाने के लिए, आपको postalAddress.administrativeArea और administrative_area_level_n टाइप (जैसे, administrative_area_level_1) वाले किसी भी addressComponents, दोनों में मैच देखना चाहिए.

Python कोड का उदाहरण

def filter_by_admin_area(results, admin_area):
    target = admin_area.upper()
    filtered = []
    for res in results:
        # Check postalAddress
        pa_aa = res.get('postalAddress', {}).get('administrativeArea', '')
        if pa_aa == target:
            filtered.append(res)
            continue
        # Check all administrative area levels in addressComponents
        for comp in res.get('addressComponents', []):
            is_admin_level = any(t.startswith('administrative_area_level_')
                               for t in comp.get('types', []))
            if is_admin_level:
                short = comp.get('shortText', '')
                if short == target:
                    filtered.append(res)
                    break
    return filtered

# Example usage:
# filtered = filter_by_admin_area(v4_response.get('results', []), 'CA')

Node.js कोड का उदाहरण

function filterByAdminArea(results, adminArea) {
    const target = adminArea.toUpperCase();
    return results.filter(res => {
        // Check postalAddress.administrativeArea
        if (res.postalAddress?.administrativeArea === target) {
            return true;
        }
        // Check addressComponents for any administrative area level
        return res.addressComponents?.some(c => {
            const isAdmin = c.types?.some(t => t.startsWith('administrative_area_level_'));
            return isAdmin && c.shortText === target;
        });
    });
}

// Example usage:
// const filtered = filterByAdminArea(v4Response.results, 'CA');

पिन कोड के हिसाब से फ़िल्टर करना

अपने अनुरोध में मौजूद address.postalCode को हर नतीजे में मौजूद postalAddress.postalCode से मैच करें. तुलना करने से पहले, आपको इनपुट और नतीजे, दोनों के पिन कोड को सामान्य करना होगा. नॉर्मलाइज़ेशन लॉजिक, इलाके पर काफ़ी निर्भर करता है. एक बुनियादी तरीका यह है कि स्पेस और हाइफ़न हटा दिए जाएं और टेक्स्ट को एक ही केस में बदल दिया जाए.

पिन कोड के प्रीफ़िक्स (जैसे, यूनाइटेड किंगडम में "L2") या सफ़िक्स (जैसे, अमेरिका के पिन कोड में "+4") को मैनेज करने के लिए, ज़्यादा बेहतर नॉर्मलाइज़ेशन की ज़रूरत पड़ सकती है. नॉर्मलाइज़ेशन के लिए ज़रूरी लॉजिक, देश और पिन कोड के फ़ॉर्मैट के हिसाब से अलग-अलग होगा. आपको उपलब्ध कराए गए नॉर्मलाइज़ेशन फ़ंक्शन को ज़रूरत के हिसाब से अडजस्ट करना पड़ सकता है. इसके अलावा, टारगेट किए जा रहे इलाकों के लिए ज़्यादा बेहतर लॉजिक लागू करना पड़ सकता है.

यहां दिए गए उदाहरण में, अमेरिका के पिन कोड को हैंडल किया गया है. साथ ही, इसमें पांच अंकों के बेस पर मैच करने की अनुमति दी गई है. भले ही, ZIP+4 दिया गया हो या दिखाया गया हो.

Python कोड का उदाहरण (अमेरिका के पिन कोड पर आधारित)

import re

def normalize_postal_code_us(pc):
    # Basic normalization for US: uppercase, alphanumeric only
    if not pc:
        return ""
    normalized = re.sub(r'[^A-Z0-9]', '', pc.upper())
    # Return only the first 5 digits for US ZIP codes
    return normalized[:5]

def filter_by_postal_code_us(results, postal_code):
    normalized_input = normalize_postal_code_us(postal_code)
    if not normalized_input:
        return []
    filtered_results = []
    for res in results:
        pa_pc = res.get('postalAddress', {}).get('postalCode', '')
        if normalize_postal_code_us(pa_pc) == normalized_input:
            filtered_results.append(res)
    return filtered_results

# Example usage:
# Matches '94043', '94043-1351', '940431351'
# filtered = filter_by_postal_code_us(v4_response.get('results', []), '94043')
# filtered = filter_by_postal_code_us(v4_response.get('results', []), '94043-1234')

Node.js कोड का उदाहरण (अमेरिका के पिन कोड पर आधारित)

function normalizePostalCodeUs(pc) {
    // Basic normalization for US: uppercase, alphanumeric only
    const normalized = (pc || '').toUpperCase().replace(/[^A-Z0-9]/g, '');
    // Return only the first 5 digits for US ZIP codes
    return normalized.substring(0, 5);
}

function filterByPostalCodeUs(results, postalCode) {
    const normalizedInput = normalizePostalCodeUs(postalCode);
    if (!normalizedInput) {
        return [];
    }
    return results.filter(res => {
        const paPc = res.postalAddress?.postalCode || '';
        return normalizePostalCodeUs(paPc) === normalizedInput;
    });
}

// Example usage:
// Matches '94043', '94043-1351', '940431351'
// const filtered = filterByPostalCodeUs(v4Response.results, '94043');
// const filtered = filterByPostalCodeUs(v4Response.results, '94043-1234');

v3 रिवर्स जियोकोडिंग से माइग्रेट करना

अगर निर्देशांकों को पतों में बदलने के लिए, v3 रिवर्स जियोकोडिंग का इस्तेमाल किया जाता है, तो आपको v4 किसी जगह को रिवर्स जियोकोड करें तरीके पर माइग्रेट करना चाहिए. यह तरीका, GET अनुरोध को स्वीकार करता है.

अनुरोध के पैरामीटर में बदलाव करना

v3 पैरामीटर	v4 पैरामीटर	नोट
`language`	`languageCode`	नाम बदला गया. अगर v3 में भाषा की जानकारी नहीं दी जाती है, तो यह `Accept-Language` हेडर का इस्तेमाल करता है या डिफ़ॉल्ट रूप से `en` पर सेट हो जाता है. वहीं, v4 डिफ़ॉल्ट रूप से जगह की स्थानीय भाषा और स्क्रिप्ट पर सेट हो जाता है.
`region`	`regionCode`	नाम बदला गया. अगर इसे शामिल नहीं किया जाता है, तो v3 की डिफ़ॉल्ट वैल्यू `us` होती है. वहीं, v4 की कोई डिफ़ॉल्ट वैल्यू नहीं होती है.
`result_type`	`types`	नाम बदला गया; बार-बार इस्तेमाल होने वाले क्वेरी पैरामीटर का इस्तेमाल करता है.
`location_type`	`granularity`	नाम बदला गया; बार-बार इस्तेमाल होने वाले क्वेरी पैरामीटर का इस्तेमाल करता है.
`extra_computations`	हटाया गया	इसकी जगह SearchDestinations तरीके का इस्तेमाल किया जाता है.

जवाब वाले फ़ील्ड में बदलाव

v3 फ़ील्ड	v4 फ़ील्ड	नोट
`status`, `error_message`	हटाया गया	v4, एचटीटीपी स्टेटस कोड और गड़बड़ी की जानकारी देने वाले मैसेज का इस्तेमाल करता है.
`results.address_components.long_name` / `results.address_components.short_name`	`results.addressComponents.longText` / `results.addressComponents.shortText`	नाम बदला गया.
`results.geometry.location_type`	`results.granularity`	नाम बदला गया.
`results.geometry.location`	`results.location`	फ़ील्ड के नाम: `lat`/`lng` -> `latitude`/`longitude`.
`results.geometry.viewport`	`results.viewport`	फ़ील्ड के नाम: `northeast`/`southwest` -> `high`/`low`.
नया	`results.addressComponents.languageCode`	पते के किसी कॉम्पोनेंट की भाषा.
नया	`results.bounds`	`high`/`low` का इस्तेमाल करके, साफ़ तौर पर सीमाएं तय की गई हैं.
नया	`results.place`	जगह के लिए संसाधन का नाम.
नया	`results.postalAddress`	स्ट्रक्चर्ड `PostalAddress` ऑब्जेक्ट.

v3 Address descriptors से माइग्रेट करना

Geocoding API v3 में, extra_computations=ADDRESS_DESCRIPTORS को पास करने पर, address_descriptor ऑब्जेक्ट मिलता था. इसमें landmarks[] और areas[] शामिल होते थे. Geocoding API v4 में, इस सुविधा को SearchDestinations तरीके (POST /v4/geocode/destinations) से बदल दिया गया है. यह तरीका, हर Destination ऑब्जेक्ट में सीधे तौर पर ज़्यादा जानकारी वाला स्पेशल कॉन्टेक्स्ट दिखाता है.

नीचे दी गई टेबल में, लेगसी v3 address_descriptor फ़ील्ड को उनके v4 SearchDestinations के बराबर फ़ील्ड के साथ मैप किया गया है:

v3 `address_descriptor` फ़ील्ड	v4 `SearchDestinations` फ़ील्ड	माइग्रेशन से जुड़े नोट
`landmarks[]`	`destinations[].landmarks[]`	`X-Goog-FieldMask` में `destinations.landmarks` का अनुरोध करें.
`landmarks[].place_id`	`landmarks[].place.placeId`	`place` (`PlaceView`) ऑब्जेक्ट में रैप किया गया है.
`landmarks[].display_name`	`landmarks[].place.displayName`	स्थानीय भाषा में टेक्स्ट (`text` और `languageCode`).
`landmarks[].types`	`landmarks[].place.types`	जगह के टाइप की स्ट्रिंग का कलेक्शन.
`landmarks[].spatial_relationship`	`landmarks[].relationalDescription`	v4, रॉ एनम (`ACROSS_THE_ROAD`, `AROUND_THE_CORNER`) के बजाय, स्थानीय भाषा में लिखा गया ऐसा वाक्यांश दिखाता है जिसे कोई व्यक्ति आसानी से पढ़ सके (उदाहरण के लिए, `"Across from Central Park"`).
`landmarks[].straight_line_distance_meters`	`landmarks[].straightLineDistanceMeters`	नाम बदलकर lower camelCase किया गया.
`landmarks[].travel_distance_meters`	`landmarks[].travelDistanceMeters`	नाम बदलकर lower camelCase किया गया.
`areas[]` (`containment` enum)	`destinations[].containingPlaces[]` और `subDestinations[]`	स्ट्रक्चरल हैरारकी के लिए सबसे नज़दीकी उपलब्ध विकल्प: आस-पास के कॉम्प्लेक्स, कैंपस, मॉल, और इमारतों को `containingPlaces[]` और `subDestinations[]` में स्ट्रक्चर्ड `PlaceView` ऑब्जेक्ट के तौर पर दिखाया जाता है. इसमें `structureType` को `GROUNDS` या `BUILDING` पर सेट किया जाता है. साथ ही, इसमें `displayPolygon` आउटलाइन का विकल्प भी होता है. ध्यान दें कि आस-पास के इलाकों/डिस्ट्रिक्ट या v3 `containment` enum (`NEAR`, `WITHIN`, `OUTSKIRTS`) के लिए, कोई डायरेक्ट 1:1 रिप्लेसमेंट नहीं है.

v3 प्लेस जियोकोडिंग से माइग्रेट करना

अगर आपको Geocoding v3 का इस्तेमाल करके, किसी जगह के आईडी का पता पाने के लिए place_id का इस्तेमाल करना है, तो आपको v4 Place Geocoding तरीके पर माइग्रेट करना होगा. यह तरीका, GET अनुरोध को स्वीकार करता है.

अनुरोध के पैरामीटर में बदलाव करना

v3 पैरामीटर	v4 पैरामीटर	नोट
`place_id`	अनुरोध प्रोटो में `place` फ़ील्ड	जगह के आईडी को अब पाथ पैरामीटर `places/{place}` के तौर पर दिया जाता है. उदाहरण के लिए: `https://geocode.googleapis.com/v4/geocode/places/ChIJj61dQgK6j4AR4GeTYWZsKWw`. यह, अनुरोध में मौजूद जगह के फ़ील्ड से मैप होता है.
`language`	`languageCode`	नाम बदला गया. अगर v3 में भाषा की जानकारी नहीं दी जाती है, तो यह `Accept-Language` हेडर का इस्तेमाल करता है या डिफ़ॉल्ट रूप से `en` पर सेट हो जाता है. वहीं, v4 डिफ़ॉल्ट रूप से जगह की स्थानीय भाषा और स्क्रिप्ट पर सेट हो जाता है.
`region`	`regionCode`	नाम बदला गया. अगर इसे शामिल नहीं किया जाता है, तो v3 की डिफ़ॉल्ट वैल्यू `us` होती है. वहीं, v4 की कोई डिफ़ॉल्ट वैल्यू नहीं होती है.

जवाब वाले फ़ील्ड में बदलाव

v3 फ़ील्ड	v4 फ़ील्ड	नोट
`status`, `error_message`	हटाया गया	v4, एचटीटीपी स्टेटस कोड और गड़बड़ी की जानकारी देने वाले मैसेज का इस्तेमाल करता है.
`results`	(root)	v4, एक नतीजा ऑब्जेक्ट दिखाता है, न कि `results` कलेक्शन.
`results.address_components.long_name` / `results.address_components.short_name`	`addressComponents.longText` / `addressComponents.shortText`	नाम बदला गया.
`results.geometry.location_type`	`granularity`	नाम बदला गया.
`results.geometry.location`	`location`	फ़ील्ड के नाम: `lat`/`lng` -> `latitude`/`longitude`.
`results.geometry.viewport`	`viewport`	फ़ील्ड के नाम: `northeast`/`southwest` -> `high`/`low`.
`results.postcode_localities`	`postalCodeLocalities`	नाम बदला गया. अब एक या उससे ज़्यादा इलाकों के लिए नतीजे दिखाए जाते हैं (v3 के लिए, 1 से ज़्यादा नतीजे ज़रूरी हैं).
नया	`addressComponents.languageCode`	पते के किसी कॉम्पोनेंट की भाषा.
नया	`bounds`	`high`/`low` का इस्तेमाल करके, साफ़ तौर पर सीमाएं तय की गई हैं.
नया	`place`	जगह के लिए संसाधन का नाम.
नया	`postalAddress`	स्ट्रक्चर्ड `PostalAddress` ऑब्जेक्ट.

जियोकोडिंग हाइपरलोकल डेटा से डेस्टिनेशन पर माइग्रेट करना

Geocoding API v3 की इन सुविधाओं को, Geocoding API v4 के SearchDestinations तरीके से बदला जा रहा है:

एंट्रेंस
नेविगेशन पॉइंट
इमारतों की आउटलाइन
मैदान

अगर ऊपर बताई गई सुविधाओं के लिए Geocoding API v3 का इस्तेमाल किया जा रहा था, तो इस दस्तावेज़ का इस्तेमाल करके, इन सुविधाओं को पाने के लिए SearchDestinations तरीके का इस्तेमाल करें. इस दस्तावेज़ में बताया गया है कि SearchDestinations के रिस्पॉन्स में ये सुविधाएं कहां मिलेंगी. साथ ही, यह भी बताया गया है कि Geocoding API v3 और Geocoding API v4 के SearchDestinations तरीके के बीच, एपीआई के रिस्पॉन्स में ये सुविधाएं किस तरह अलग-अलग दिखती हैं.

एंट्रेंस

destination से जुड़े एंट्री पॉइंट पाने के लिए, destination.entrances फ़ील्ड का इस्तेमाल करें.

destination.entrances में मौजूद हर entrance में ये फ़ील्ड होते हैं. ये फ़ील्ड, लेगसी v3 buildings.entrances स्कीमा की जगह लेते हैं:

displayName - यह एक नया वैकल्पिक फ़ील्ड है. इसमें एंट्री पॉइंट का ऐसा नाम शामिल होता है जिसे कोई व्यक्ति आसानी से पढ़ सके. उदाहरण के लिए, "Gate B".
location - latitude और longitude का इस्तेमाल करके, LatLng टाइप की जगह की जानकारी (v3 lat/lng की जगह).
tags - Geocoding API v3 के एंट्रेंस (जैसे, PREFERRED) के tags फ़ील्ड की तरह ही.
place - जगह के संसाधन का नाम (उदाहरण के लिए, places/ChIJ...). यह Geocoding API v3 के building_place_id फ़ील्ड की जगह लेता है. v4 में, यह जगह किसी भी डेस्टिनेशन स्ट्रक्चर (इमारत, कैंपस या पार्क) को दिखा सकती है, न कि सिर्फ़ किसी इमारत को.

नेविगेशन पॉइंट

destination से जुड़े नेविगेशन पॉइंट पाने के लिए, destination.navigationPoints फ़ील्ड का इस्तेमाल करें.

destination.navigationPoints में मौजूद हर navigationPoint में ये फ़ील्ड होते हैं. ये फ़ील्ड, लेगसी v3 navigation_points स्कीमा की जगह लेते हैं:

navigationPointToken - एन्क्रिप्ट की गई टोकन स्ट्रिंग, जिसका इस्तेमाल Routes API ComputeRoutes तरीके (Waypoint.navigationPointToken) में इस खास नेविगेशन पॉइंट पर रूट करने के लिए किया जाता है. नेविगेशन पॉइंट टोकन का इस्तेमाल करके रूट करना देखें.
displayName - यह एक नया वैकल्पिक फ़ील्ड है. इसमें नेविगेशन पॉइंट का ऐसा नाम शामिल होता है जिसे कोई भी व्यक्ति आसानी से पढ़ सकता है. उदाहरण के लिए, "5th Ave".
location - latitude और longitude का इस्तेमाल करके, LatLng टाइप की जगह.
travelModes - यह Geocoding API v3 के restricted_travel_modes फ़ील्ड से मिलता-जुलता है. हालांकि, v4 में पाबंदी वाले यात्रा मोड के बजाय, स्वीकार किए जाने वाले यात्रा मोड (DRIVE, WALK) के बारे में बताया गया है.
usage - यह एक नया फ़ील्ड है. इसमें नेविगेशन पॉइंट के लिए, इस्तेमाल के उन मामलों की जानकारी दी जाती है जो काम करते हैं. जैसे, PICKUP, DROPOFF या PARKING.

इमारतों की आउटलाइन

किसी destination से जुड़ी बिल्डिंग की आउटलाइन पाने के लिए, destination में मौजूद placeView ऑब्जेक्ट के displayPolygon फ़ील्ड का इस्तेमाल करें. ये ऑब्जेक्ट, बिल्डिंग को दिखाते हैं. साथ ही, ये लेगसी v3 buildings.building_outlines कलेक्शन की जगह लेते हैं. हर placeView के लिए, देखें कि क्या यह placeView.structureType फ़ील्ड वाली इमारत है. अगर स्ट्रक्चर टाइप BUILDING है, तो placeView.displayPolygon फ़ील्ड से आउटलाइन देखी जा सकती है. placeView में बिल्डिंग के लिए अतिरिक्त फ़ील्ड भी होंगे, जो Geocoding API v3 में नहीं थे.

ध्यान दें: क्या आपको किसी जगह पर मौजूद इमारत का पॉलीगॉन देखना है? नतीजों को सीमित करने के लिए, अपने अनुरोध में placeFilter पैरामीटर का इस्तेमाल किया जा सकता है. सिर्फ़ बिल्डिंग के नतीजे पाने के लिए, placeFilter में structureType को "BUILDING" पर सेट करें. अगर पॉलीगॉन पाना आपकी प्राथमिकता है (भले ही, उन जगहों के लिए जिनके सटीक पते मौजूद नहीं हैं), तो placeFilter में addressability को "ANY" पर सेट करें, ताकि सबसे सटीक पॉलीगॉन मिल सके.

उदाहरण

{
  "locationQuery": {
    "location": {
      "latitude": 37.4224,
      "longitude": -122.0841
    },
    "placeFilter": {
      "structureType": "BUILDING",
      "addressability": "ANY"
    }
  }
}

destination में placeView ऑब्जेक्ट हो सकता है. यह ऑब्जेक्ट, इन फ़ील्ड में किसी इमारत को दिखाता है:

destination.primary - डेस्टिनेशन की मुख्य जगह.
destination.containingPlaces - दोहराया गया फ़ील्ड, जिसमें मुख्य जगह को "शामिल" करने वाली बड़ी जगहों की जानकारी होती है. उदाहरण के लिए, अगर मुख्य जगह subpremise है, तो आम तौर पर containingPlaces में placeView होता है, जो इमारत को दिखाता है.
destination.subDestinations - यह एक दोहराया गया फ़ील्ड है, जिसमें मुख्य जगह के सब-डेस्टिनेशन की जानकारी होती है. उदाहरण के लिए, किसी बिल्डिंग में मौजूद अलग-अलग अपार्टमेंट यूनिट या सुइट.

ध्यान दें कि placeView.displayPolygon का फ़ॉर्मैट, Geocoding API v3 में बिल्डिंग की आउटलाइन के फ़ॉर्मैट से मेल खाता है. यह GeoJSON फ़ॉर्मैट है, जिसमें आरएफ़सी 7946 फ़ॉर्मैट का इस्तेमाल किया जाता है.

मैदान

बिल्डिंग की आउटलाइन बनाने की तरह ही, किसी destination से जुड़े ग्राउंड की जानकारी पाने के लिए, destination में मौजूद placeView ऑब्जेक्ट के displayPolygon फ़ील्ड का इस्तेमाल करें. ये ऑब्जेक्ट, ग्राउंड को दिखाते हैं. साथ ही, ये लेगसी v3 grounds कलेक्शन की जगह लेते हैं. हर placeView के लिए, देखें कि क्या यह placeView.structureType फ़ील्ड वाला ग्राउंड पॉलीगॉन है. अगर स्ट्रक्चर टाइप GROUNDS है, तो placeView.displayPolygon फ़ील्ड से आउटलाइन मिल सकती है. placeView में, उन जगहों के लिए अतिरिक्त फ़ील्ड भी होंगे जो Geocoding API v3 में नहीं थे.

destination में placeView ऑब्जेक्ट हो सकता है. यह ऑब्जेक्ट, इन फ़ील्ड में ग्राउंड को दिखाता है:

destination.primary
destination.containingPlaces
destination.subDestinations

ध्यान दें कि placeView.displayPolygon का फ़ॉर्मैट, Geocoding API v3 में ग्राउंड आउटलाइन के फ़ॉर्मैट से मेल खाता है. यह GeoJSON फ़ॉर्मैट है, जो आरएफ़सी 7946 फ़ॉर्मैट का इस्तेमाल करता है.

नतीजों की सटीकता

Geocoding API v3 में, रिस्पॉन्स ज्यामिति में मौजूद location_type फ़ील्ड से नतीजों की सटीक जानकारी मिलती थी. साथ ही, कुछ क्लाइंट इन वैल्यू (ROOFTOP, RANGE_INTERPOLATED, GEOMETRIC_CENTER, और APPROXIMATE) के आधार पर नतीजों को रैंक या फ़िल्टर करते थे. Geocoding API v4 के स्टैंडर्ड माइग्रेशन में, इस फ़ील्ड का नाम बदलकर granularity कर दिया गया है.

Destinations API (v4 SearchDestinations) में, location_type फ़ील्ड नहीं है. इसके बजाय, स्पेशल ऑडियो की जानकारी को अलग तरीके से मैनेज किया जाता है:

क्लाइंट-साइड पर मैन्युअल तरीके से फ़िल्टर करने की ज़रूरत नहीं है: स्टैंडर्ड जियोकोडिंग, अलग-अलग बारीकियों के हिसाब से कई नतीजे देती है. हालांकि, SearchDestinations तरीका, जब भी संभव हो, एक ही ऑप्टिमाइज़ किए गए डेस्टिनेशन पर ले जाकर, भ्रम को कम करता है. इससे क्लाइंट को जगह के टाइप के हिसाब से फ़िल्टर करने की ज़रूरत नहीं पड़ती, ताकि वे यह तय कर सकें कि कौनसा नतीजा सबसे अच्छा है.
स्ट्रक्चर टाइप और डिसप्ले पॉलीगॉन से दिखाई गई जगह की जानकारी: जगह की ज्यामिति और स्ट्रक्चर को इनसे दिखाया जाता है:
- displayPolygon (सटीक ज्यामिति के लिए).
- placeView ऑब्जेक्ट में मौजूद structureType फ़ील्ड.
स्ट्रक्चर टाइप की मैपिंग:
- POINT, BUILDING या SECTION के structureType का मतलब आम तौर पर वही होता है जिसे पहले ROOFTOP कहा जाता था.
- GROUNDS का structureType आम तौर पर GEOMETRIC_CENTER के बराबर होता है.

इन सुविधाओं का अनुरोध करने के लिए, फ़ील्ड मास्क का इस्तेमाल करना

SearchDestinations तरीके के लिए, फ़ील्ड मास्क की ज़रूरत होती है. इसके बारे में नतीजों में दिखाने के लिए फ़ील्ड चुनें में बताया गया है. सभी फ़ील्ड की वैल्यू पाने के लिए, फ़ील्ड मास्क को * पर सेट किया जा सकता है. इसके अलावा, इसे उन फ़ील्ड पर सेट किया जा सकता है जिनकी वैल्यू आपको चाहिए. उदाहरण के लिए, यहां दिया गया एपीआई अनुरोध, फ़ील्ड मास्क को सेट करता है, ताकि किसी डेस्टिनेशन के प्रवेश द्वार, नेविगेशन पॉइंट, बिल्डिंग की आउटलाइन, और ग्राउंड की जानकारी पाने के लिए ज़रूरी सभी फ़ील्ड मिल सकें:

curl -X POST -d '{"place": "places/ChIJG3kh4hq6j4AR_XuFQnV0_t8"}' \
  -H "X-Goog-Api-Key: API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Goog-FieldMask: destinations.entrances,destinations.navigationPoints,destinations.primary,destinations.containingPlaces,destinations.subDestinations" \
  https://geocode.googleapis.com/v4/geocode/destinations

माइग्रेशन के सामान्य तरीके और कोड पैटर्न

Geocoding v3 या Geocoding++ से SearchDestinations पर मुश्किल वर्कफ़्लो माइग्रेट करते समय, सामान्य स्पेस और पते के स्ट्रक्चर निकालने के लिए, यहां दिए गए कोड रेसिपी का इस्तेमाल करें.

इमारत का सबसे अच्छा पॉलीगॉन निकालना

अगर आपको किसी जगह या मंज़िल के लिए बिल्डिंग फ़ुटप्रिंट रेंडर करना है, तो:

देखें कि primary जगह में structureType === 'BUILDING' है या नहीं और उसमें displayPolygon है या नहीं.
अगर ऐसा नहीं है, तो containingPlaces की जांच करके, उस इमारत का पता लगाएं जिसमें यह जगह मौजूद है. यह तब काम आता है, जब मुख्य डेस्टिनेशन, किसी बड़ी इमारत का सब-डेस्टिनेशन हो.
अगर कोई बिल्डिंग नहीं मिलती है, तो subDestinations पर जाकर देखें कि अलग-अलग बिल्डिंग की सूची मौजूद है या नहीं.

Python कोड का उदाहरण

def get_best_building_polygon(destination):
    primary = destination.get('primary', {})
    if primary.get('structureType') == 'BUILDING' and 'displayPolygon' in primary:
        return primary['displayPolygon']

    # Check containing places for the parent building
    for place in destination.get('containingPlaces', []):
        if place.get('structureType') == 'BUILDING' and 'displayPolygon' in place:
            return place['displayPolygon']

    # Fallback to sub-destinations if available
    for place in destination.get('subDestinations', []):
        if place.get('structureType') == 'BUILDING' and 'displayPolygon' in place:
            return place['displayPolygon']

    return None

Node.js कोड का उदाहरण

function getBestBuildingPolygon(destination) {
    const { primary = {}, containingPlaces = [], subDestinations = [] } = destination;

    if (primary.structureType === 'BUILDING' && primary.displayPolygon) {
        return primary.displayPolygon;
    }

    const parentBuilding = containingPlaces.find(
        p => p.structureType === 'BUILDING' && p.displayPolygon
    );
    if (parentBuilding) {
        return parentBuilding.displayPolygon;
    }

    const subBuilding = subDestinations.find(
        p => p.structureType === 'BUILDING' && p.displayPolygon
    );
    return subBuilding?.displayPolygon || null;
}

मैदान की आउटलाइन एक्सट्रैक्ट करना

अगर आपको किसी अपार्टमेंट कॉम्प्लेक्स, कॉर्पोरेट कैंपस, शॉपिंग सेंटर या पार्क की सीमा की जानकारी देनी है, तो:

अगर primary जगह, पूरे कॉम्प्लेक्स (structureType === 'GROUNDS') को दिखाती है, तो primary.displayPolygon का इस्तेमाल करें.
अगर primary जगह, किसी बड़े कॉम्प्लेक्स के अंदर मौजूद कोई इमारत या प्रवेश द्वार है, तो containingPlaces में मौजूद आस-पास के ग्राउंड ढूंढें.

Python कोड का उदाहरण

def get_grounds_polygon(destination):
    primary = destination.get('primary', {})
    if primary.get('structureType') == 'GROUNDS' and 'displayPolygon' in primary:
        return primary['displayPolygon']

    for place in destination.get('containingPlaces', []):
        if place.get('structureType') == 'GROUNDS' and 'displayPolygon' in place:
            return place['displayPolygon']

    return None

Node.js कोड का उदाहरण

function getGroundsPolygon(destination) {
    const { primary = {}, containingPlaces = [] } = destination;

    if (primary.structureType === 'GROUNDS' && primary.displayPolygon) {
        return primary.displayPolygon;
    }

    const groundsPlace = containingPlaces.find(
        p => p.structureType === 'GROUNDS' && p.displayPolygon
    );
    return groundsPlace?.displayPolygon || null;
}

लैंडमार्क चुनना, ताकि पता दिखाया जा सके और आखिरी मील तक पहुंचने की जानकारी दी जा सके

Geocoding v3 address_descriptor ने spatial_relationship enum (WITHIN, BESIDE, BEHIND, NEAR, ACROSS_THE_ROAD, AROUND_THE_CORNER) दिखाया. SearchDestinations में:

रिलेशनशिप के लिए कोई रॉ एनम नहीं है. इसके बजाय, सीधे relationalDescription.text का इस्तेमाल करें. इसमें स्थानीय भाषा के हिसाब से, दिखाए जाने के लिए तैयार वाक्यांश शामिल होते हैं. जैसे, "Across from Central Park" या "Behind the convention center". "Near " को मैन्युअल तरीके से प्रीपेंड न करें.
अपने इस्तेमाल के उदाहरण के लिए सही लैंडमार्क चुनने के लिए, tags का इस्तेमाल करें:
- ARRIVAL: हाइपरलोकल लैंडमार्क, जो मंज़िल के ठीक बगल में, सामने या सड़क के पार मौजूद होते हैं. आम तौर पर, ये 50 से 100 मीटर के दायरे में होते हैं. यह रीयल-टाइम में ड्राइवर के पहुंचने की जानकारी, कूरियर डिलीवरी की पुष्टि या इन-ऐप्लिकेशन अराइवल कार्ड के लिए सबसे सही है.
- ADDRESS: आस-पास के इलाके में मौजूद लोकप्रिय लैंडमार्क (आम तौर पर 100 से 500 मीटर के दायरे में). यह स्टाइल, ग्राहक को चेकआउट, ऑर्डर की समीक्षा या यात्रा से पहले मंज़िल की जानकारी देने के लिए सबसे सही है.
- अगर किसी लैंडमार्क में ADDRESS और ARRIVAL, दोनों टैग हैं, तो इसका मतलब है कि वह आस-पास के इलाके में मशहूर है और मंज़िल के ठीक बगल में है.

Python कोड का उदाहरण

def get_best_relational_landmark(destination, is_last_mile=True):
    """Select the best landmark based on user context.

    Args:
        destination: Destination object from SearchDestinations.
        is_last_mile: True for arrival and delivery guidance (prefers ARRIVAL tags).
                      False for address display and disambiguation (prefers ADDRESS tags).

    Returns:
        Dict with landmark description, distances, tags, and placeId, or None.
    """
    landmarks = destination.get('landmarks', [])
    if not landmarks:
        return None

    target_tag = 'ARRIVAL' if is_last_mile else 'ADDRESS'

    # Landmarks are ranked by relevance and proximity. Select the first candidate matching the target tag.
    for lm in landmarks:
        tags = lm.get('tags', [])
        if target_tag in tags or ('ARRIVAL' in tags and 'ADDRESS' in tags):
            description = lm.get('relationalDescription', {}).get('text')
            if description:
                return {
                    'description': description,
                    'travelDistanceMeters': lm.get('travelDistanceMeters'),
                    'straightLineDistanceMeters': lm.get('straightLineDistanceMeters'),
                    'tags': tags,
                    'placeId': lm.get('place', {}).get('placeId')
                }

    # Fallback to the first available landmark with a relational description if no tagged match is found
    for lm in landmarks:
        description = lm.get('relationalDescription', {}).get('text')
        if description:
            return {
                'description': description,
                'travelDistanceMeters': lm.get('travelDistanceMeters'),
                'straightLineDistanceMeters': lm.get('straightLineDistanceMeters'),
                'tags': lm.get('tags', []),
                'placeId': lm.get('place', {}).get('placeId')
            }

    return None

Node.js कोड का उदाहरण

/**
 * Select the best landmark based on user context.
 *
 * @param {Object} destination Destination object from SearchDestinations.
 * @param {boolean} [isLastMile=true] True for arrival and delivery guidance
 *        (prefers ARRIVAL tags). False for address display and disambiguation
 *        (prefers ADDRESS tags).
 * @return {Object|null}
 */
function getBestRelationalLandmark(destination, isLastMile = true) {
    const landmarks = destination.landmarks || [];
    if (!landmarks.length) return null;

    const targetTag = isLastMile ? 'ARRIVAL' : 'ADDRESS';

    // Landmarks are ranked by relevance and proximity. Select the first candidate matching the target tag.
    const match = landmarks.find((lm) => {
        const tags = lm.tags || [];
        return (tags.includes(targetTag) || (tags.includes('ARRIVAL') && tags.includes('ADDRESS'))) &&
               lm.relationalDescription?.text;
    }) || landmarks.find((lm) => lm.relationalDescription?.text);

    if (match) {
        return {
            description: match.relationalDescription.text,
            travelDistanceMeters: match.travelDistanceMeters,
            straightLineDistanceMeters: match.straightLineDistanceMeters,
            tags: match.tags || [],
            placeId: match.place?.placeId || null,
        };
    }

    return null;
}

वाहन के नेविगेशन पॉइंट और पसंदीदा एंट्री पॉइंट तक का रास्ता

लास्ट-माइल डिस्पैच और अराइवल वर्कफ़्लो, दो तरह के स्पेशल ऐक्सेस पॉइंट को जोड़ते हैं:

मोड़-दर-मोड़ ड्राइविंग: navigationPoints का इस्तेमाल करके, वाहनों को सड़क पर तय किए गए ड्रॉप-ऑफ़ पॉइंट पर ले जाएं. नेविगेशन पॉइंट, नज़दीकी और काम के होने के हिसाब से पहले से रैंक किए जाते हैं. इसलिए, आपकी पसंद के यात्रा के मोड (जैसे, 'DRIVE') और इस्तेमाल के टैग (जैसे, 'DROPOFF' या 'PICKUP') के साथ पहला विकल्प, वाहन के लिए सबसे सही वेपॉइंट उपलब्ध कराता है. Routes API के ComputeRoutes तरीके (Waypoint.navigationPointToken) या Navigation SDK को इसका navigationPointToken भेजें. अगर सड़क से जुड़ा कोई ड्राइविंग पॉइंट मौजूद नहीं है, तो इमारत के मुख्य दरवाज़े या प्राइमरी सेंट्रॉइड पर वापस जाएं.
इमारत में जाने का रास्ता: destinations.entrances का इस्तेमाल करके, कूरियर या यात्री को इमारत में जाने का रास्ता बताएं. 'PREFERRED' के लिए tags देखें, ताकि आपको ऐसे दरवाज़े मिल सकें जिनसे सीधे तौर पर अंदर जाया जा सके. अगर एंट्री पॉइंट का कोई डेटा उपलब्ध नहीं है, तो पैदल चलने वालों के लिए नेविगेशन पॉइंट (travelModes के साथ-साथ 'WALK') या प्राइमरी सेंट्रॉइड पर वापस जाएं.

Python कोड का उदाहरण

def get_routing_and_arrival_points(destination, usage_tag=None):
    navigation_points = destination.get('navigationPoints', [])
    entrances = destination.get('entrances', [])
    primary_location = destination.get('primary', {}).get('location')

    # 1. Doorstep / Physical Entrance
    # Prefer PREFERRED entrance -> any entrance -> WALK nav point -> primary location
    preferred_entrance = None
    for ent in entrances:
        if 'PREFERRED' in ent.get('tags', []):
            preferred_entrance = ent
            break
    if not preferred_entrance and entrances:
        preferred_entrance = entrances[0]

    walk_nav_point = None
    for np in navigation_points:
        if 'WALK' in np.get('travelModes', []):
            walk_nav_point = np
            break

    if preferred_entrance:
        doorstep_location = preferred_entrance.get('location')
    elif walk_nav_point:
        doorstep_location = walk_nav_point.get('location')
    else:
        doorstep_location = primary_location

    # 2. Vehicle Routing Waypoint
    # Find a driving navigation point. If usage_tag (such as 'DROPOFF' or 'PICKUP')
    # is specified, prioritize a candidate with that usage tag; otherwise fall back
    # to the first available driving point.
    drive_nav_point = None
    fallback_drive_point = None
    for np in navigation_points:
        if 'DRIVE' in np.get('travelModes', []):
            if usage_tag and usage_tag in np.get('usages', []):
                drive_nav_point = np
                break  # Exact match for desired usage tag
            elif fallback_drive_point is None:
                fallback_drive_point = np  # First driving point as fallback

    if not drive_nav_point:
        drive_nav_point = fallback_drive_point

    if drive_nav_point:
        vehicle_location = drive_nav_point.get('location')
        nav_token = drive_nav_point.get('navigationPointToken')
    elif preferred_entrance:
        vehicle_location = preferred_entrance.get('location')
        nav_token = None
    else:
        vehicle_location = primary_location
        nav_token = None

    return {
        'vehicleRoutingWaypoint': {
            'navigationPointToken': nav_token,
            'location': vehicle_location,
        },
        'doorstepLocation': doorstep_location,
    }

Node.js कोड का उदाहरण

function getRoutingAndArrivalPoints(destination, usageTag = null) {
    const navigationPoints = destination.navigationPoints || [];
    const entrances = destination.entrances || [];
    const primaryLocation = destination.primary?.location || null;

    // 1. Doorstep / Physical Entrance
    const preferredEntrance = entrances.find(ent => ent.tags?.includes('PREFERRED'))
        || entrances[0]
        || null;

    const walkNavPoint = navigationPoints.find(np => np.travelModes?.includes('WALK'))
        || null;

    const doorstepLocation = preferredEntrance?.location
        || walkNavPoint?.location
        || primaryLocation;

    // 2. Vehicle Routing Waypoint
    // Find a driving navigation point. If usageTag (such as 'DROPOFF' or 'PICKUP')
    // is specified, prioritize a candidate with that usage tag; otherwise fall back
    // to the first available driving point.
    const driveNavPoint = (usageTag && navigationPoints.find(np => np.travelModes?.includes('DRIVE') && np.usages?.includes(usageTag)))
        || navigationPoints.find(np => np.travelModes?.includes('DRIVE'))
        || null;

    let vehicleLocation = primaryLocation;
    let navToken = null;
    if (driveNavPoint) {
        vehicleLocation = driveNavPoint.location;
        navToken = driveNavPoint.navigationPointToken;
    } else if (preferredEntrance) {
        vehicleLocation = preferredEntrance.location;
    }

    return {
        vehicleRoutingWaypoint: {
            navigationPointToken: navToken,
            location: vehicleLocation,
        },
        doorstepLocation: doorstepLocation,
    };
}

सुरक्षा से जुड़ी ज़रूरी बातें

Geocoding API v4 को सर्वर-टू-सर्वर एपीआई के तौर पर डिज़ाइन किया गया है. JavaScript का इस्तेमाल करने वाले उपयोगकर्ताओं के लिए, v3 से v4 पर माइग्रेट करने का कोई सीधा तरीका नहीं है. एपीआई पासकोड का इस्तेमाल करके, क्लाइंट-साइड JavaScript (उदाहरण के लिए, ब्राउज़र में) से सीधे v4 के तरीकों को कॉल करने पर, आपके एपीआई पासकोड के चोरी होने और उसका गलत इस्तेमाल होने का खतरा बढ़ जाता है.

एचटीटीपी रेफ़रलकर्ता से जुड़ी पाबंदियां, वेब सेवा के एंडपॉइंट की सुरक्षा के लिए काफ़ी नहीं हैं. हालांकि, ये पाबंदियां काम की हैं. ऐसा इसलिए, क्योंकि हमलावर अपने अनुरोधों में Referer हेडर को फ़र्ज़ी बनाकर, इन पाबंदियों को आसानी से बायपास कर सकते हैं.

सुझाया गया तरीका

Geocoding API v4 का इस्तेमाल करने का सबसे सही तरीका यह है कि इसे अपने बैकएंड सर्वर से इस्तेमाल किया जाए. आपके क्लाइंट ऐप्लिकेशन को इस इंटरमीडियरी सर्वर को अनुरोध भेजने चाहिए. इसके बाद, यह सर्वर सुरक्षित एपीआई पासकोड का इस्तेमाल करके, Google API को सुरक्षित तरीके से कॉल करता है. उदाहरण के लिए, एनवायरमेंट वैरिएबल या Secret Manager में सेव किया गया पासकोड. इससे यह पक्का होता है कि आपकी एपीआई कुंजी, फ़्रंटएंड कोड में कभी भी ज़ाहिर न हो.

क्लाइंट-साइड की ज़रूरतों के लिए विकल्प

अगर आपको क्लाइंट-साइड पर जियोकोडिंग की ज़रूरत है, तो इनमें से किसी एक मौजूदा क्लाइंट-साइड समाधान का इस्तेमाल करें:

Maps JavaScript API में जियोकोडिंग सेवा: जियोकोडिंग सेवा, v3 बैकएंड का इस्तेमाल करती है. इसे ब्राउज़र एनवायरमेंट में इस्तेमाल करने के लिए डिज़ाइन किया गया है.
जगहों की जानकारी देने वाली यूआई किट: पते से जुड़े यूज़र इंटरफ़ेस एलिमेंट के लिए, जगहों की जानकारी देने वाली यूआई किट का इस्तेमाल करें. इसमें किसी जगह के शुरुआती अक्षर लिखने पर पूरा नाम सुझाने की सुविधा वाले एलिमेंट शामिल हैं.