एंडपॉइंट

इस पेज पर, REST API के नियमों की खास जानकारी दी गई है. साथ ही, Google Health API के सामान्य टास्क और हर टास्क के उदाहरणों की सूची दी गई है.

REST API के नियम

Google Health API, Google API Improvement Proposals (AIP) के स्टैंडर्ड का पालन करता है. खास तौर पर, AIP-127 (एचटीटीपी और gRPC ट्रांसकोडिंग) और AIP-131 से लेकर AIP-135 (स्टैंडर्ड तरीके) तक. इन स्टैंडर्ड से यह तय होता है कि प्रोटो मैसेज से एचटीटीपी अनुरोध में डेटा को कैसे मैप किया जाता है.

क्वेरी पैरामीटर

क्वेरी पैरामीटर का इस्तेमाल तब किया जाता है, जब डेटा यूआरएल का हिस्सा हो. इसका इस्तेमाल मुख्य रूप से GET अनुरोधों (किसी संसाधन को फ़ेच करने) या LIST अनुरोधों (फ़िल्टर करने/पेज पर नंबर डालने) के लिए किया जाता है. हालांकि, इसका इस्तेमाल DELETE कार्रवाइयों के लिए भी किया जाता है.

  • प्लेसमेंट: ? के बाद यूआरएल में जोड़ा जाता है.
  • सिंटैक्स: की-वैल्यू पेयर को & से अलग किया जाता है.
  • मैपिंग: अनुरोध मैसेज का हर वह फ़ील्ड जो यूआरएल पाथ टेंप्लेट का हिस्सा नहीं है, उसे क्वेरी पैरामीटर से मैप किया जाता है.
  • इनके लिए सबसे सही: आसान टाइप (स्ट्रिंग, इंट, इनम) और दोहराए गए फ़ील्ड.

फ़िल्टर फ़ॉर्मैट, फ़ील्ड रेफ़रंस, पुष्टि करने के नियमों, और उदाहरणों की पूरी सूची के लिए, डेटा फ़िल्टर करने की गाइड देखें.

सिंटैक्स का उदाहरण:

GET https://health.googleapis.com/v4/users/me/dataTypes/data-type/dataPoints?page_size=10&filter=data_type.interval.start_time >= "2025-10-01T00:00:00Z"

अनुरोध का मुख्य भाग

अनुरोध के मुख्य हिस्से का इस्तेमाल तब किया जाता है, जब डेटा किसी संसाधन की स्थिति में बदलाव करता है या यूआरएल के लिए बहुत बड़ा होता है. आम तौर पर, बॉडी में संसाधन को JSON के तौर पर दिखाया जाता है. आम तौर पर, इसका इस्तेमाल POST, PATCH, और PUT कार्रवाइयों के लिए किया जाता है.

  • प्लेसमेंट: एचटीटीपी पेलोड के अंदर (यूआरएल में नहीं दिखता).
  • सिंटैक्स: JSON ऑब्जेक्ट के तौर पर फ़ॉर्मैट किया गया.
  • मैपिंग: इसे google.api.http एनोटेशन में तय किया गया है.
    • body: "*" का मतलब है कि पूरा मैसेज ही मुख्य हिस्सा है.
    • body: "resource_name" का मतलब है कि प्रोटो में सिर्फ़ एक खास फ़ील्ड, बॉडी है.
  • इनके लिए सबसे सही: मुश्किल ऑब्जेक्ट, नेस्ट किए गए मैसेज, और संवेदनशील डेटा.

रोलअप विंडो के साइज़, बकेटिंग के नियमों, और एग्रीगेशन के उदाहरणों के बारे में ज़्यादा जानने के लिए, कुल डेटा की गाइड देखें.

सिंटैक्स का उदाहरण:

POST https://health.googleapis.com/v4/users/me/dataTypes/data-type/dataPoints:rollUp
Content-Type: application/json

{
  "range": {
    "startTime": "2025-11-05T00:00:00Z",
    "endTime": "2025-11-13T00:00:00Z"
  },
  "windowSize": "3600s"
}

हाइब्रिड केस

एआईपी-134 के मुताबिक Update तरीके या PATCH ऑपरेशन में, दोनों का इस्तेमाल किया जाता है. यूआरएल में संसाधन का नाम होता है. मुख्य हिस्से में, अपडेट किया गया संसाधन डेटा होता है. साथ ही, क्वेरी पैरामीटर (आम तौर पर update_mask) से यह तय होता है कि किन फ़ील्ड में बदलाव करना है.

PATCH https://health.googleapis.com/v4/projects/project-id/subscribers/subscriber-id
Content-Type: application/json

{
  "endpointUri": "https://myapp.com/new-webhooks/health"
}

एक नज़र में मुख्य अंतर

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

तारीख

Google Health API में सभी तारीखें, YYYY-MM-DD फ़ॉर्मैट में दिखती हैं. Nutrition API, तारीख की वैल्यू के लिए आईएसओ-8601 स्टैंडर्ड के साथ काम करता है. इसके लिए, ये शर्तें पूरी करनी होंगी:

  • साल को चार अंकों में डालें YYYY
  • साल की वैल्यू 0000 से 9999 के बीच होनी चाहिए
  • ISO-8601 स्टैंडर्ड या अन्य epoch के मुताबिक, शुरू होने की तारीख से जुड़ी पाबंदियां लागू नहीं की जाती हैं

हेडर

Google Health API के एंडपॉइंट को लागू करने के लिए, सही हेडर और ऐक्सेस टोकन का इस्तेमाल करना ज़रूरी है. GET और POST, दोनों अनुरोधों के लिए, यहां दिए गए हेडर का सुझाव दिया जाता है:

Authorization: Bearer access-token
Accept: application/json

एपीआई टास्क इंडेक्स

इस सेक्शन में, Google Health API के सामान्य टास्क का इंडेक्स और हर टास्क के उदाहरण दिए गए हैं.

Fitbit या Google का यूज़र आईडी पाना

जब कोई उपयोगकर्ता Google OAuth 2.0 के ज़रिए सहमति देता है, तो टोकन रिस्पॉन्स में Fitbit या Google का यूज़र आईडी शामिल नहीं होता. legacyUserId और healthUserId, दोनों को वापस पाने के लिए, ऑथराइज़ेशन कोड को एक्सचेंज करने के तुरंत बाद, getIdentity एंडपॉइंट को कॉल करें. साथ ही, पुष्टि करें कि उपयोगकर्ता का Google खाता, Google Health से लिंक है. अगर खाता अब तक लिंक नहीं किया गया है, तो getIdentity, 400 Bad Request को ACCOUNT_NOT_LINKED वजह के साथ दिखाता है (लिंक नहीं किए गए Google खातों को मैनेज करना देखें).

उदाहरण के लिए:

अनुरोध

GET https://health.googleapis.com/v4/users/me/identity
Authorization: Bearer access-token
Accept: application/json

जवाब (200 OK)

{
  "name": "users/me/identity",
  "legacyUserId": "A1B2C3",
  "healthUserId": "111111256096816351"
}

Response (400 ACCOUNT_NOT_LINKED)

{
  "error": {
    "code": 400,
    "message": "The account is not linked to Google Health.",
    "status": "FAILED_PRECONDITION",
    "details": [
      {
        "@type": "type.googleapis.com/google.rpc.ErrorInfo",
        "reason": "ACCOUNT_NOT_LINKED",
        "domain": "health.googleapis.com",
        "metadata": {
          "redirect_uri": "https://fitbit.google.com/auth/signup"
        }
      }
    ]
  }
}

दिन के दौरान या पूरे दिन इकट्ठा किया गया डेटा पाना

किसी खास डेटा टाइप के लिए, list एंडपॉइंट का इस्तेमाल करें. इससे आपको उस डेटा टाइप के लिए, दिन के दौरान या पूरे दिन इकट्ठा किए गए डेटा की जानकारी, तय किए गए अंतराल पर मिलेगी.

उदाहरण के लिए:

अनुरोध

GET https://health.googleapis.com/v4/users/me/dataTypes/steps/dataPoints
Authorization: Bearer access-token
Accept: application/json

जवाब

{
  "dataPoints": [
    {
      "dataSource": {
        "recordingMethod": "PASSIVELY_MEASURED",
        "device": {
          "manufacturer": "",
          "displayName": "Charge 6"
        },
        "platform": "FITBIT"
      },
      "steps": {
        "interval": {
          "startTime": "2026-03-04T07:05:00Z",
          "startUtcOffset": "0s",
          "endTime": "2026-03-04T07:06:00Z",
          "endUtcOffset": "0s",
          "civilStartTime": {
            "date": {
              "year": 2026,
              "month": 3,
              "day": 4
            },
            "time": {
              "hours": 7,
              "minutes": 5
            }
          },
          "civilEndTime": {
            "date": {
              "year": 2026,
              "month": 3,
              "day": 4
            },
            "time": {
              "hours": 7,
              "minutes": 6
            }
          }
        },
        "count": "40"
      }
    },
...
  ],
  "nextPageToken": "Xm5h-6L0viZxIlRuWjx5bmvy98zj85uG34tuMn16mu2pntsnZI32iqhq"
}

इंटरवल डेटा का मिलान किया गया व्यू पाना

ओवरलैप होने वाले रिकॉर्ड या मल्टी-डिवाइस से जुड़ी समस्याओं के बिना इंटरवल डेटा पाने के लिए, reconcile एंडपॉइंट को कॉल करें. रीकंसाइल एंडपॉइंट, सिंक किए गए बैच और कई रिकॉर्डिंग डिवाइसों के बीच ओवरलैप होने वाले इंटरवल की डुप्लीकेट कॉपी अपने-आप हटा देता है. इससे, गतिविधि की टाइमलाइन रेंडर करने और अवधि का हिसाब लगाने के लिए, एक भरोसेमंद और लगातार स्ट्रीम मिलती है.

कनेक्ट किए गए डिवाइसों से ओवरलैप होने वाले इंटरवल क्यों जनरेट होते हैं, इस बारे में ज़्यादा जानने के लिए, डेटा मैनेजमेंट गाइड देखें. इसमें list और reconcile के बीच काम करने के तरीके की तुलना भी की गई है.

यहां दिए गए उदाहरण में, list और reconcile के जवाबों की तुलना की गई है. इसमें, एक उपयोगकर्ता के लिए कसरत के दो ऐसे सेशन दिखाए गए हैं जो ओवरलैप हो रहे हैं. , ओवरलैप होने वाले दोनों रिकॉर्ड दिखाता है. वहीं, , आधिकारिक रिकॉर्ड दिखाकर समस्या को हल करता है:

रॉ लिस्ट

GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints
Authorization: Bearer access-token
Accept: application/json
 
{
  "dataPoints": [
    {
      "name": "users/111111256096816351/dataTypes/exercise/dataPoints/7797422996486764704",
      "exercise": {
        "interval": {
          "startTime": "2026-09-03T11:20:00Z",
          "endTime": "2026-09-03T11:50:00Z"
        },
        "exerciseType": "RUNNING"
      }
    },
    {
      "name": "users/111111256096816351/dataTypes/exercise/dataPoints/4389052750481144696",
      "exercise": {
        "interval": {
          "startTime": "2026-09-03T11:00:00Z",
          "endTime": "2026-09-03T11:30:00Z"
        },
        "exerciseType": "RUNNING"
      }
    }
  ]
}

पेमेंट से जुड़ा समाधान

GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints:reconcile
Authorization: Bearer access-token
Accept: application/json
 
{
  "dataPoints": [
    {
      "dataPointName": "users/111111256096816351/dataTypes/exercise/dataPoints/7797422996486764704",
      "exercise": {
        "interval": {
          "startTime": "2026-09-03T11:20:00Z",
          "endTime": "2026-09-03T11:50:00Z"
        },
        "exerciseType": "RUNNING"
      }
    }
  ]
}

रिकॉन्सिलिएशन की प्रोसेस, डुप्लीकेट कॉपी हटाकर और आधिकारिक रिकॉर्ड चुनकर, एक-दूसरे से मेल न खाने वाले सेशन की समस्या को हल करती है. यह प्रोसेस, समय के आधार पर आर्टिफ़िशियल यूनियन (जैसे, 11:00:00Z से 11:50:00Z) बनाने के बजाय, आधिकारिक रिकॉर्ड चुनती है. रिकॉन्सिल किए गए रिस्पॉन्स में, सबसे सही डेटा पॉइंट (7797422996486764704) और उसके ओरिजनल रिकॉर्ड किए गए इंटरवल (11:20:00Z से 11:50:00Z) की जानकारी मिलती है. इससे उस सेशन के लिए मेज़र की गई टेलीमेट्री और मेट्रिक की इंटिग्रिटी बनी रहती है.

डेटा फ़िल्टर करें

समय अंतराल, तारीख या निगरानी के समय जैसी शर्तों से मैच करने वाले डेटा पॉइंट रिकॉर्ड के सबसेट को वापस पाने के लिए, filter पैरामीटर के साथ list या reconcile एंडपॉइंट का इस्तेमाल करें.

ज़्यादा जानकारी वाले दिशा-निर्देश, फ़ॉर्मैटिंग के नियम, पुष्टि करने से जुड़ी गड़बड़ियां, और क्वेरी के उदाहरण देखने के लिए, डेटा फ़िल्टर करने की गाइड देखें.

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

किसी खास तरह के सोर्स (उदाहरण के लिए, पहने जाने वाले डिवाइस बनाम मैन्युअल एंट्री) से डेटा को अलग करने या इकट्ठा करने के लिए, dataSourceFamily पैरामीटर का इस्तेमाल करें.

reconcile, rollUp, और dailyRollUp के लिए, ज़्यादा जानकारी वाले दिशा-निर्देश, डेटा सोर्स की काम करने वाली फ़ैमिली, और अनुरोध और जवाब के उदाहरण देखने के लिए, डेटा फ़िल्टर करने की गाइड में डेटा सोर्स फ़ैमिली के हिसाब से फ़िल्टर करें लेख पढ़ें.

इंटरवल सिविल के शुरू होने के समय के हिसाब से डेटा फ़िल्टर करना

सिविल टाइम या किसी इंटरवल के हिसाब से डेटा फ़िल्टर करने के लिए, filter पैरामीटर के साथ list एंडपॉइंट का इस्तेमाल करें.

उदाहरण के लिए:

अनुरोध

GET https://health.googleapis.com/v4/users/me/dataTypes/steps/dataPoints?filter=steps.interval.civil_start_time >= "2026-03-04T00:00:00"
Authorization: Bearer access-token
Accept: application/json

जवाब

{
  "dataPoints": [
    {
      "dataSource": {
        "recordingMethod": "PASSIVELY_MEASURED",
        "device": {
          "manufacturer": "",
          "displayName": "Charge 6"
        },
        "platform": "FITBIT"
      },
      "steps": {
        "interval": {
          "startTime": "2026-03-04T07:05:00Z",
          "startUtcOffset": "0s",
          "endTime": "2026-03-04T07:06:00Z",
          "endUtcOffset": "0s",
          "civilStartTime": {
            "date": {
              "year": 2026,
              "month": 3,
              "day": 4
            },
            "time": {
              "hours": 7,
              "minutes": 5
            }
          },
          "civilEndTime": {
            "date": {
              "year": 2026,
              "month": 3,
              "day": 4
            },
            "time": {
              "hours": 7,
              "minutes": 6
            }
          }
        },
        "count": "40"
      }
...
  ],
  "nextPageToken": "Xm5h-6L0viZxIlRuQjp5bml1bZ4ve2dhNmZvMnt4Yn7qIGQhbHN3YQ"
}

सैंपल ऑब्ज़र्वेशन के फ़िज़िकल टाइम के हिसाब से डेटा फ़िल्टर करना

सैंपल ऑब्ज़र्वेशन के फ़िज़िकल टाइम के हिसाब से डेटा को फ़िल्टर करने के लिए, filter पैरामीटर के साथ list एंडपॉइंट का इस्तेमाल करें.

उदाहरण के लिए:

अनुरोध

GET https://health.googleapis.com/v4/users/me/dataTypes/body-fat/dataPoints?filter=body_fat.sample_time.physical_time >= "2026-03-01T00:00:00Z"
Authorization: Bearer access-token
Accept: application/json

जवाब

{
  "dataPoints": [
    {
      "name": "users/123456789/dataTypes/body-fat/dataPoints/1234567890",
      "dataSource": {
        "recordingMethod": "UNKNOWN",
        "application": {
          "packageName": "",
          "webClientId": "",
          "googleWebClientId": "google-web-client-id"
        },
        "platform": "GOOGLE_WEB_API"
      },
      "bodyFat": {
        "sampleTime": {
          "physicalTime": "2026-03-10T10:00:00Z",
          "utcOffset": "0s",
          "civilTime": {
            "date": {
              "year": 2026,
              "month": 3,
              "day": 10
            },
            "time": {
              "hours": 10
            }
          }
        },
        "percentage": 20
      }
    }
  "nextPageToken": ""
}

डेटा सोर्स फ़ैमिली के हिसाब से फ़िल्टर और एग्रीगेट करना

डेटा सोर्स फ़ैमिली, डेटा सोर्स का एक लॉजिकल ग्रुप होता है. जैसे, स्मार्टवॉच, मोबाइल ऐप्लिकेशन या मैन्युअल एंट्री. इसकी मदद से, खास तरह के सोर्स से मिले डेटा को अलग किया जा सकता है या इकट्ठा किया जा सकता है. उदाहरण के लिए, पहने जाने वाले डिवाइसों से मिले डेटा को मैन्युअल तरीके से डाले गए डेटा से अलग किया जा सकता है.

reconcile, rollUp, और dailyRollUp एंडपॉइंट, dataSourceFamily पैरामीटर के साथ काम करते हैं. पासिंग मैकेनिज़्म, एंडपॉइंट पर निर्भर करता है:

एंडपॉइंट (एचटीटीपी तरीका) मैकेनिज़्म
reconcile (GET) dataSourceFamily को यूआरएल क्वेरी पैरामीटर के तौर पर पास करें.
rollUp (POST) JSON अनुरोध के मुख्य हिस्से में, फ़ील्ड के तौर पर dataSourceFamily को पास करें.
dailyRollUp (POST) JSON अनुरोध के मुख्य हिस्से में, फ़ील्ड के तौर पर dataSourceFamily को पास करें.

इस्तेमाल किए जा सकने वाले डेटा सोर्स फ़ैमिली

यहां दी गई टेबल में, dataSourceFamily के लिए इस्तेमाल की जा सकने वाली वैल्यू के बारे में बताया गया है:

विकल्प ब्यौरा
users/me/dataSourceFamilies/all-sources डिफ़ॉल्ट मान. यह रजिस्टर किए गए पहले पक्ष (1P) और तीसरे पक्ष (3P) के सभी डेटा सोर्स से मिले डेटा पॉइंट दिखाता है. इस विकल्प से, तीसरे पक्ष के ऐप्लिकेशन का डेटा दिखेगा. जैसे, स्मार्टवॉच से रिकॉर्ड किए गए कदमों की संख्या + तीसरे पक्ष के ऐप्लिकेशन से रिकॉर्ड किए गए कदमों की संख्या + मोबाइल फ़ोन से रिकॉर्ड किए गए कदमों की संख्या + मैन्युअल तरीके से रिकॉर्ड किए गए कदमों की संख्या.
users/me/dataSourceFamilies/google-wearables इसमें Google और Fitbit ट्रैकर डिवाइसों (जैसे, Fitbit के पहने जाने वाले ट्रैकर और Pixel Watch) से रिकॉर्ड किया गया डेटा शामिल है. इसमें मैन्युअल तरीके से लॉग किया गया डेटा और फ़ोन से अनुमानित डेटा शामिल नहीं है. इस विकल्प का इस्तेमाल तब करें, जब आपके इंटिग्रेशन के लिए, पहने जाने वाले हार्डवेयर से सीधे तौर पर रिकॉर्ड की गई रॉ सेंसर टेलीमेट्री की ज़रूरत हो.
users/me/dataSourceFamilies/google-sources इसमें Google और Fitbit के पहले पक्ष के सोर्स शामिल हैं. इसमें फ़िज़िकल ट्रैकर डिवाइस के रिकॉर्ड, Health Connect से मिला डेटा, और पहले पक्ष के ऐप्लिकेशन (जैसे, Fitbit ऐप्लिकेशन या Google Fit) से मैन्युअल तरीके से लॉग की गई कोई भी एंट्री शामिल है.

किसी खास डेटा सोर्स फ़ैमिली से, मिलान की गई डेटा स्ट्रीम पाने के लिए, dataSourceFamily क्वेरी पैरामीटर के साथ reconcile एंडपॉइंट को कॉल करें.

उदाहरण के लिए, यहां दिया गया जीईटी अनुरोध, 03-03-2026 के बाद के दिन के लिए, ट्रैकर से रिकॉर्ड की गई नींद का डेटा फ़ेच करता है:

अनुरोध

GET https://health.googleapis.com/v4/users/me/dataTypes/sleep/dataPoints:reconcile?dataSourceFamily=users/me/dataSourceFamilies/google-wearables&filter=sleep.interval.civil_end_time >= "2026-03-03"
Authorization: Bearer access-token
Accept: application/json

जवाब

{
  "dataPoints": [
    {
      "name": "users/2515055256096816351/dataTypes/sleep/dataPoints/2724123844716220216",
      "dataSource": {
        "recordingMethod": "DERIVED",
        "device": {
          "displayName": "Charge 6"
        },
        "platform": "FITBIT"
      },
      "sleep": {
        "interval": {
          "startTime": "2026-03-03T20:57:30Z",
          "startUtcOffset": "0s",
          "endTime": "2026-03-04T04:41:30Z",
          "endUtcOffset": "0s"
        },
        "type": "STAGES",
        "stages": [
          {
            "startTime": "2026-03-03T20:57:30Z",
            "startUtcOffset": "0s",
            "endTime": "2026-03-03T20:59:30Z",
            "endUtcOffset": "0s",
            "type": "AWAKE",
            "createTime": "2026-03-04T04:43:40.937183Z",
            "updateTime": "2026-03-04T04:43:40.937183Z"
          },
          {
            "startTime": "2026-03-04T04:07:30Z",
            "startUtcOffset": "0s",
            "endTime": "2026-03-04T04:41:30Z",
            "endUtcOffset": "0s",
            "type": "AWAKE",
            "createTime": "2026-03-04T04:43:40.937183Z",
            "updateTime": "2026-03-04T04:43:40.937183Z"
          }
        ],
        "metadata": {
          "stagesStatus": "SUCCEEDED",
          "processed": true,
          "main": true
        },
        "summary": {
          "minutesInSleepPeriod": "464",
          "minutesAfterWakeUp": "0",
          "minutesToFallAsleep": "0",
          "minutesAsleep": "407",
          "minutesAwake": "57",
          "stagesSummary": [
            {
              "type": "AWAKE",
              "minutes": "56",
              "count": "12"
            },
            {
              "type": "LIGHT",
              "minutes": "198",
              "count": "19"
            },
            {
              "type": "DEEP",
              "minutes": "114",
              "count": "10"
            },
            {
              "type": "REM",
              "minutes": "94",
              "count": "4"
            }
          ]
        },
        "createTime": "2026-03-04T04:43:40.337983Z",
        "updateTime": "2026-03-04T04:43:40.937183Z"
      }
    }
  ],
  "nextPageToken": ""
}

डेटा सोर्स की किसी खास फ़ैमिली तक सीमित विंडो साइज़ के डेटा पॉइंट को एग्रीगेट करने के लिए, rollUp एंडपॉइंट को कॉल करें. साथ ही, JSON अनुरोध के मुख्य हिस्से में dataSourceFamily फ़ील्ड को पास करें.

यहां दिए गए पोस्ट अनुरोध से, हर घंटे के इंटरवल (3600s) पर इंट्रा-डे पैदल चलने के कदमों की संख्या के बारे में क्वेरी की जाती है. यह डेटा, सिर्फ़ पहने जाने वाले डिवाइसों से इकट्ठा किया जाता है:

अनुरोध

POST https://health.googleapis.com/v4/users/me/dataTypes/steps/dataPoints:rollUp
Authorization: Bearer access-token
Accept: application/json

{
  "range": {
    "startTime": "2026-07-29T00:00:00Z",
    "endTime": "2026-07-29T23:59:59Z"
  },
  "windowSize": "3600s",
  "dataSourceFamily": "users/me/dataSourceFamilies/google-wearables"
}

जवाब

{
  "rollupDataPoints": [
    {
      "startTime": "2026-07-29T08:00:00Z",
      "endTime": "2026-07-29T09:00:00Z",
      "steps": {
        "countSum": "1200"
      }
    },
    {
      "startTime": "2026-07-29T09:00:00Z",
      "endTime": "2026-07-29T10:00:00Z",
      "steps": {
        "countSum": "3450"
      }
    }
  ]
}

किसी खास सोर्स फ़ैमिली के लिए, हर दिन के डेटा पॉइंट इकट्ठा करने के लिए, dailyRollUp एंडपॉइंट को कॉल करें. साथ ही, अनुरोध के मुख्य हिस्से में dataSourceFamily फ़ील्ड को पास करें.

उदाहरण के लिए, यहां दिए गए अनुरोध से उपयोगकर्ता के कदमों की संख्या का रोज़ाना का रोलअप कैलकुलेट किया जाता है. इसमें Google और Fitbit के सभी फ़र्स्ट पार्टी सोर्स (पहने जाने वाले डिवाइस + मैन्युअल तरीके से की गई एंट्री) शामिल हैं:

अनुरोध

POST https://health.googleapis.com/v4/users/me/dataTypes/steps/dataPoints:dailyRollUp
Authorization: Bearer access-token
Accept: application/json

{
  "range": {
    "start": {
      "date": {
        "year": 2026,
        "month": 7,
        "day": 28
      },
      "time": {
        "hours": 0,
        "minutes": 0,
        "seconds": 0,
        "nanos": 0
      }
    },
    "end": {
      "date": {
        "year": 2026,
        "month": 7,
        "day": 30
      },
      "time": {
        "hours": 0,
        "minutes": 0,
        "seconds": 0,
        "nanos": 0
      }
    }
  },
  "windowSizeDays": 1,
  "dataSourceFamily": "users/me/dataSourceFamilies/google-sources"
}

जवाब

{
  "rollupDataPoints": [
    {
      "civilStartTime": {
        "date": {
          "year": 2026,
          "month": 7,
          "day": 28
        },
        "time": {}
      },
      "civilEndTime": {
        "date": {
          "year": 2026,
          "month": 7,
          "day": 28
        },
        "time": {
          "hours": 23,
          "minutes": 59,
          "seconds": 59
        }
      },
      "steps": {
        "countSum": "8430"
      }
    },
    {
      "civilStartTime": {
        "date": {
          "year": 2026,
          "month": 7,
          "day": 29
        },
        "time": {}
      },
      "civilEndTime": {
        "date": {
          "year": 2026,
          "month": 7,
          "day": 29
        },
        "time": {
          "hours": 23,
          "minutes": 59,
          "seconds": 59
        }
      },
      "steps": {
        "countSum": "11245"
      }
    }
  ]
}

किसी समयावधि के दौरान डेटा पॉइंट एग्रीगेट करना

rollUp एंडपॉइंट का इस्तेमाल करके, सेकंड (windowSize) में किसी विंडो के आधार पर डेटा पॉइंट का एग्रीगेट दिखाएं. यह एग्रीगेट, उपयोगकर्ता के फ़िज़िकल टाइम (यूटीसी में) में datetime रेंज के हिसाब से दिखाया जाता है.

rollUp एंडपॉइंट को कॉल करते समय, अनुरोध का मुख्य हिस्सा दें. इसमें, बंद होने और खुलने का ज़रूरी समय range और windowSize (कम से कम "1s") शामिल होना चाहिए. windowSize की ज़रूरी शर्तों, स्टोरेज रिज़ॉल्यूशन अलाइनमेंट, बकेटिंग के नियमों, और अनुरोध और जवाब के उदाहरणों के बारे में ज़्यादा जानने के लिए, कुल डेटा की गाइड में फ़िज़िकल टाइम इंटरवल के हिसाब से एग्रीगेट करना लेख पढ़ें.

एक या उससे ज़्यादा दिनों का कुल डेटा

एक या उससे ज़्यादा दिनों (windowSizeDays) का डेटा इकट्ठा करने के लिए, dailyRollUp एंडपॉइंट का इस्तेमाल करें. अनुरोध के मुख्य हिस्से में, ज़रूरी समयावधि के लिए क्लोज़्ड-ओपन सिविल टाइम range दें. डेटा टाइप के आधार पर, एंडपॉइंट हर विंडो के लिए कुल वैल्यू या औसत वैल्यू दिखाता है.

हर दिन के डेटा को एग्रीगेट करने के तरीके, सिविल टाइम को मैनेज करने, हर अनुरोध के लिए रेंज की सीमाओं, और अनुरोध और रिस्पॉन्स के उदाहरणों के बारे में जानने के लिए, कुल डेटा की गाइड में कैलेंडर के दिनों के हिसाब से डेटा एग्रीगेट करना लेख पढ़ें.

उपयोगकर्ता की सेहत का डेटा अपडेट करना

किसी उपयोगकर्ता की सेहत का डेटा अपडेट करने के लिए, patch एंडपॉइंट का इस्तेमाल करें.

patch एंडपॉइंट, अनुरोध के यूआरएल में दिए गए आइडेंटिफ़ायर के आधार पर, किसी मौजूदा रिकॉर्ड को अपडेट करता है. पहले से डाले गए डेटा पॉइंट का आइडेंटिफ़ायर दें. एपीआई, मौजूदा रिकॉर्ड को ओवरराइट कर देता है.

किसी डेटा पॉइंट के इंटरवल टाइमस्टैंप (startTime और endTime) को भी रिकॉर्ड का मालिक अपडेट कर सकता है. इसके अलावा, Health Connect जैसे अपस्ट्रीम प्लैटफ़ॉर्म से भी इन्हें अपडेट किया जा सकता है. टाइमस्टैंप में बदलाव करने के बारे में ज़्यादा जानने के लिए, डेटा मैनेजमेंट गाइड देखें. इंटरवल टाइमस्टैंप को अपडेट करने का उदाहरण देखने के लिए, मौजूदा डेटा के लिए इंटरवल टाइमस्टैंप अपडेट करना लेख पढ़ें.

डेटा पॉइंट आइडेंटिफ़ायर का इस्तेमाल कब करना चाहिए

डेटा पॉइंट आइडेंटिफ़ायर इन स्थितियों में ज़रूरी है:

  • टारगेट किए गए अपडेट: किसी खास मेज़रमेंट को अपडेट करने के लिए, patch अनुरोध में उसका आइडेंटिफ़ायर दें.
  • मिटाना: आइडेंटिफ़ायर को सेव रखने से, आपके ऐप्लिकेशन को बाद में batchDelete एंडपॉइंट का इस्तेमाल करके रिकॉर्ड मिटाने की सुविधा मिलती है.

यहां एक उदाहरण दिया गया है, जिसमें कोई उपयोगकर्ता "Scales R Us" कंपनी के "HumanScale" नाम के स्केल पर, अपने शरीर में मौजूद बॉडी फ़ैट की रीडिंग को अपडेट करता है. उपयोगकर्ता के शरीर में मौजूद फै़ट की नई रीडिंग, 10-03-2026 के लिए 20% है:

अनुरोध

PATCH https://health.googleapis.com/v4/users/me/dataTypes/body-fat/dataPoints/1234567890
Authorization: Bearer access-token
Content-Type: application/json

{
  "name": "users/me/dataTypes/body-fat/dataPoints/1234567890",
  "dataSource": {
    "recordingMethod": "ACTIVELY_MEASURED",
    "device": {
      "formFactor": "SCALE",
      "manufacturer": "Scales R Us",
      "displayName": "HumanScale"
    }
  },
  "bodyFat": {
    "sampleTime": {
      "physicalTime": "2026-03-10T10:00:00Z"
    },
    "percentage": 20
  }
}

जवाब

{
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.devicesandservices.health.v4main.DataPoint",
    "name": "users/123456789/dataTypes/body-fat/dataPoints/1234567890",
    "dataSource": {
      "recordingMethod": "ACTIVELY_MEASURED",
      "device": {
        "formFactor": "SCALE",
        "manufacturer": "Scales R Us",
        "displayName": "HumanScale"
      },
      "application": {
        "googleWebClientId": "618308034039.apps.googleusercontent.com"
      },
      "platform": "GOOGLE_WEB_API"
    },
    "bodyFat": {
      "sampleTime": {
        "physicalTime": "2026-03-10T10:00:00Z"
      },
      "percentage": 20
    }
  }
}

मौजूदा डेटा के लिए, इंटरवल के टाइमस्टैंप अपडेट करना

किसी मौजूदा डेटा पॉइंट के इंटरवल टाइमस्टैंप (REST JSON पेलोड में startTime और endTime या gRPC में start_time और end_time) को अपडेट करने के लिए, डेटा पॉइंट के रिसॉर्स यूआरआई पर PATCH अनुरोध भेजें. किसी रिकॉर्ड के फ़ील्ड में बदलाव करने का विकल्प, सिर्फ़ उसके ओरिजनल क्रिएटर या मालिक के पास होता है. ऐप्लिकेशन, उन डेटा पॉइंट में बदलाव नहीं कर सकते जिन्हें उन्होंने नहीं बनाया है.

टाइमस्टैंप में बदलाव करने, Health Connect से अपस्ट्रीम अपडेट पाने, और कैश मेमोरी में डेटा सेव करने के बारे में जानने के लिए, डेटा मैनेजमेंट गाइड देखें.

यहां दिए गए उदाहरण में, मालिक के ऐप्लिकेशन को patch एंडपॉइंट का इस्तेमाल करके, हाइड्रेशन के मौजूदा लॉग के इंटरवल टाइमस्टैंप को अपडेट करते हुए दिखाया गया है:

अनुरोध

PATCH https://health.googleapis.com/v4/users/me/dataTypes/hydration-log/dataPoints/4093039283164890826
Authorization: Bearer access-token
Content-Type: application/json

{
  "hydrationLog": {
    "interval": {
      "startTime": "2026-09-03T10:05:00Z",
      "endTime": "2026-09-03T10:19:59Z"
    },
    "amountConsumed": {
      "milliliters": 350
    }
  }
}

जवाब

{
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.devicesandservices.health.v4.DataPoint",
    "name": "users/111111256096816351/dataTypes/hydration-log/dataPoints/4093039283164890826",
    "hydrationLog": {
      "interval": {
        "startTime": "2026-09-03T10:05:00Z",
        "endTime": "2026-09-03T10:19:59Z",
        "civilStartTime": {
          "date": {
            "year": 2026,
            "month": 9,
            "day": 3
          },
          "time": {
            "hours": 10,
            "minutes": 5
          }
        },
        "civilEndTime": {
          "date": {
            "year": 2026,
            "month": 9,
            "day": 3
          },
          "time": {
            "hours": 10,
            "minutes": 19,
            "seconds": 59
          }
        }
      },
      "amountConsumed": {
        "milliliters": 350
      }
    }
  }
}

खाने का कोई आइटम लॉग करना

किसी खाने-पीने की चीज़ को लॉग करने के लिए, nutrition-log dataPoints एंडपॉइंट पर POST अनुरोध भेजें. अनुरोध के मुख्य हिस्से में, nutritionLog ऑब्जेक्ट के साथ DataPoint शामिल होता है. ज़्यादा जानकारी के लिए, पोषण से जुड़ी गाइड देखें.

उदाहरण के लिए:

अनुरोध

POST https://health.googleapis.com/v4/users/me/dataTypes/nutrition-log/dataPoints
Authorization: Bearer access-token
Content-Type: application/json

{
  "nutritionLog": {
    "interval": {
      "startTime": "2026-06-16T12:00:00Z",
      "endTime": "2026-06-16T12:30:00Z"
    },
    "foodDisplayName": "Banana",
    "mealType": "LUNCH",
    "energy": {
      "kcal": 105
    },
    "totalCarbohydrate": {
      "grams": 27
    },
    "totalFat": {
      "grams": 0.3
    }
  }
}

जवाब

{
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.devicesandservices.health.v4.DataPoint",
    "name": "users/123456789/dataTypes/nutrition-log/dataPoints/567890",
    "dataSource": {
      "recordingMethod": "ACTIVELY_MEASURED",
      "platform": "GOOGLE_WEB_API"
    },
    "nutritionLog": {
      "interval": {
        "startTime": "2026-06-16T12:00:00Z",
        "startUtcOffset": "0s",
        "endTime": "2026-06-16T12:30:00Z",
        "endUtcOffset": "0s"
      },
      "energy": {
        "kcal": 105
      },
      "totalCarbohydrate": {
        "grams": 27
      },
      "totalFat": {
        "grams": 0.3
      },
      "mealType": "LUNCH",
      "foodDisplayName": "Banana"
    }
  }
}

उपयोगकर्ता की सेहत का डेटा मिटाना

किसी उपयोगकर्ता के Fitbit ऐप्लिकेशन के डेटा की कलेक्शन को मिटाने के लिए, batchDelete तरीके का इस्तेमाल करें.

यहां एक उदाहरण दिया गया है, जिसमें किसी उपयोगकर्ता ने पहले अपने बॉडी फ़ैट को रिकॉर्ड किया था, लेकिन अब उसे यह रिकॉर्ड मिटाना है. ओरिजनल इंसर्ट ऐक्शन से user-id और data-point-id का इस्तेमाल करना:

अनुरोध

POST https://health.googleapis.com/v4/users/me/dataTypes/body-fat/dataPoints:batchDelete
Authorization: Bearer access-token
Accept: application/json
content-length: 93

{
  "names": [
    "users/123456789/dataTypes/body-fat/dataPoints/1234567890"
  ]
}

जवाब

{
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.devicesandservices.health.v4main.BatchDeleteDataPointsResponse"
  }
}

डिवाइस की जानकारी ढूंढना

किसी उपयोगकर्ता के खाते से जोड़े गए डिवाइसों की सूची पाने के लिए, list एंडपॉइंट का इस्तेमाल करें. इसमें डिवाइस के मॉडल की जानकारी (deviceVersion) और Google Health के मोबाइल ऐप्लिकेशन (lastSyncTime) के साथ पिछली बार सिंक किए जाने की जानकारी शामिल है.

सूची के कॉन्फ़िगरेशन और सिंक करने की जानकारी, सिंक करने से जुड़ी समस्याओं को हल करने या पिछली बार सिंक किए जाने के बाद का पुराना डेटा फ़ेच करने के लिए काम की होती है.

उदाहरण के लिए:

अनुरोध

GET https://health.googleapis.com/v4/users/me/pairedDevices
Authorization: Bearer access-token
Accept: application/json

जवाब

{
  "pairedDevices": [
    {
      "name": "users/me/pairedDevices/123456",
      "deviceType": "TRACKER",
      "batteryStatus": "High",
      "batteryLevel": 88,
      "lastSyncTime": "2026-03-04T07:05:00Z",
      "deviceVersion": "Charge 6",
      "macAddress": "00:11:22:33:44:55",
      "features": [
        "STEPS",
        "HEART_RATE"
      ]
    }
  ]
}

पुराने डेटा के लिए क्वेरी करना

Google Health API का एक मुख्य फ़ायदा यह है कि इससे उपयोगकर्ता की परफ़ॉर्मेंस को ट्रैक किया जा सकता है. साथ ही, लंबे समय तक उसकी सेहत से जुड़ी ज़रूरी जानकारी को मॉनिटर किया जा सकता है. किसी उपयोगकर्ता के डेटा को तब तक क्वेरी किया जा सकता है, जब तक उसे रिकॉर्ड किया गया है. एपीआई, आपके ऐप्लिकेशन के इस्तेमाल किए जा सकने वाले पुराने डेटा की मात्रा पर कोई सीमा या पाबंदी नहीं लगाता.

हालांकि, पुराने डेटा के लिए क्वेरी करने पर, अब भी स्टैंडर्ड रेट लिमिट लागू होती हैं. सिस्टम को बेहतर तरीके से चलाने और पेलोड को ज़्यादा होने से रोकने के लिए, Google Health API, एंडपॉइंट के हिसाब से पेज के साइज़ के साथ, अपने-आप पेज नंबर डालने की सुविधा का इस्तेमाल करता है. इन सीमाओं और व्यवहार पर ध्यान दें:

  • पेज पर अपने-आप डेटा बांटने की सुविधा: अगर आपने लंबे समय के डेटा के लिए क्वेरी की है, तो एपीआई सिर्फ़ नतीजों का पहला पेज दिखाएगा. यह पेज, उस एंडपॉइंट के लिए तय की गई पेज साइज़ की सीमा के हिसाब से होगा. साथ ही, इसमें nextPageToken भी शामिल होगा. बाद के पेजों का अनुरोध करने के लिए, आपको nextPageToken का इस्तेमाल करना होगा.
  • पेज के साइज़ में बदलाव: कैपिंग की सीमाएं, एंडपॉइंट और डेटा टाइप पर निर्भर करती हैं. ज़्यादातर डेटा टाइप के लिए, पेज साइज़ ज़्यादा से ज़्यादा 10,000 पर सेट होता है. हालांकि, exercise और sleep जैसे कुछ डेटा टाइप के लिए, पेज का डिफ़ॉल्ट और ज़्यादा से ज़्यादा साइज़ 25 पर सेट होता है. उदाहरण के लिए, अगर कोई क्लाइंट पिछले 10 सालों की नींद का पूरा डेटा मांगता है, तो भी एपीआई पहले पेज पर नींद के सिर्फ़ 25 सेशन दिखाएगा.
  • रोलअप की तारीख की सीमा से जुड़ी पाबंदियां: डेटा रोलअप और एग्रीगेशन एंडपॉइंट (जैसे कि rollUp और dailyRollUp) के लिए, क्वेरी की तारीख की सीमाएं, डेटा टाइप के आधार पर तय की जाती हैं:
    • calories-in-heart-rate-zone, heart-rate, active-minutes, और total-calories के लिए, ज़्यादा से ज़्यादा 14 दिन की रेंज.
    • अन्य सभी रोलअप डेटा टाइप के लिए, ज़्यादा से ज़्यादा 90 दिनों की रेंज.

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

पुराने डेटा के बारे में क्वेरी करते समय, इन दिशा-निर्देशों का पालन करें. इससे, बेहतर परफ़ॉर्मेंस मिलेगी और एपीआई से जुड़ी गड़बड़ियों से बचा जा सकेगा:

फ़ेज़ के हिसाब से डेटा सिंक करना (हॉट लोड बनाम कोल्ड लोड)

  • शुरुआती "हॉट" लोड: प्राइमरी लोड सीक्वेंस के दौरान, सिर्फ़ पिछले 7 से 14 दिनों का डेटा फ़ेच और रेंडर करें. इससे यह पक्का होता है कि उपयोगकर्ताओं को डेटा तुरंत दिखे और उन्हें लंबे समय तक चलने वाली क्वेरी के लिए इंतज़ार न करना पड़े.
  • बैकग्राउंड में "कोल्ड" लोड: प्राइमरी यूज़र इंटरफ़ेस (यूआई) रेंडर होने के बाद, पुराने डेटा को वापस पाने की प्रोसेस को एसिंक्रोनस, कम प्राथमिकता वाली सूची या बैकग्राउंड में चल रही प्रोसेस को सौंपें.

एग्रीगेशन के लिए क्वेरी चंकिंग

  • रोलअप और डेली रोलअप एंडपॉइंट, तारीख की सीमा के लिए ज़्यादा से ज़्यादा समयसीमा लागू करते हैं. यह समयसीमा, डेटा टाइप के आधार पर 14 या 90 दिन की होती है. इसलिए, आपको एग्रीगेट किए गए पुराने डेटा की बड़ी क्वेरी को इन सीमाओं के अंदर, छोटे और क्रम से चलने वाले इंटरवल में बांटना होगा.
  • इन सब-क्वेरी को सुरक्षित तरीके से बैच या क्रम में लगाएं, ताकि एक साथ कई क्वेरी चलाने की सीमाओं का पालन किया जा सके और यूज़र इंटरफ़ेस (यूआई) की प्रोग्रेस इंडिकेटर को स्थिर रखा जा सके.

पहले से एग्रीगेट किए गए रोल-अप का इस्तेमाल करना

खास जानकारी वाले डैशबोर्ड और रुझान वाले चार्ट को फिर से तैयार करें, ताकि पहले से इकट्ठा किए गए और खास जानकारी वाले एंडपॉइंट (जैसे, DailyRollUpDataPoints) का इस्तेमाल किया जा सके. इससे बैकएंड पर कंप्यूट ओवरहेड और क्लाइंट को नेटवर्क ट्रांसफ़र करने में लगने वाला समय काफ़ी कम हो जाएगा.

गड़बड़ी को ठीक करने की बेहतर सुविधा (स्मार्ट तरीके से फिर से कोशिश करना)

  • अनुरोध संख्या सीमित करने (429 Too Many Requests) और सर्वर गेटवे टाइम आउट (504 Gateway Timeout) की गड़बड़ियां होने पर, एक्स्पोनेंशियल बैकऑफ़ को सख्ती से लागू करें. बड़े और फ़ेल हो चुके पेलोड को तुरंत फिर से भेजने की कोशिश न करें. तुरंत फिर से कोशिश करने से, बैकएंड पर ट्रैफ़िक बढ़ता है और सिस्टम की परफ़ॉर्मेंस खराब होती है.
पीछे जाएं
क्लाइंट लाइब्रेरी
आगे बढ़ें
फ़िल्टर