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

Google Health API, डेटा वापस पाने के स्टैंडर्ड तरीकों को कॉल करते समय, फ़िल्टर एक्सप्रेशन पर निर्भर करता है. इससे, वापस लाए गए डेटा पॉइंट को सीमित किया जा सकता है. खास तौर पर, फ़िल्टर का इस्तेमाल इनके साथ किया जाता है:

  • list एंडपॉइंट: इनकी मदद से, रॉ डेटा पॉइंट के बारे में क्वेरी की जाती है.
  • reconcile एंडपॉइंट: मिलान किए गए स्ट्रीम डेटा पॉइंट के बारे में क्वेरी करना.

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

फ़िल्टर करने के तरीके

Google Health API, Google API Improvement Proposals (AIP-160) स्टैंडर्ड के मुताबिक फ़िल्टर लागू करता है.

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

फ़िल्टर, filter पैरामीटर में यूआरएल क्वेरी स्ट्रिंग का इस्तेमाल करके पास किए जाते हैं. फ़िल्टर में खास वर्ण (जैसे कि <, >=, और कोटेशन मार्क) होते हैं. इसलिए, एचटीटीपी अनुरोध में ट्रांसमिट करते समय, उन्हें यूआरएल-कोड में बदलना ज़रूरी है.

उदाहरण के लिए, steps.interval.civil_start_time >= "2026-03-04T00:00:00" फ़िल्टर वाले अनुरोध को इस तरह से कोड में बदला जाना चाहिए:

GET https://health.googleapis.com/v4/users/me/dataTypes/steps/dataPoints
  ?filter=steps.interval.civil_start_time%20%3E%3D%20%222026-03-04T00%3A00%3A00%22

नाम का फ़ॉर्मैट

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

  • एंडपॉइंट पाथ: हाइफ़न का इस्तेमाल करें. उदाहरण के लिए, /dataTypes/body-fat.
  • फ़िल्टर स्ट्रिंग: अंडरस्कोर का इस्तेमाल करें (उदाहरण के लिए, body_fat).

अगर फ़िल्टर आइडेंटिफ़ायर में हाइफ़न का इस्तेमाल किया जाता है, तो एपीआई 400 Bad Request दिखाता है. इसमें गड़बड़ी की वजह INVALID_DATA_POINT_FILTER होती है.

फ़िल्टर के टाइप और फ़ील्ड

फ़िल्टर में इस्तेमाल किए जाने वाले फ़ील्ड, उस डेटा टाइप के रिकॉर्ड टाइप पर निर्भर करते हैं जिसके लिए क्वेरी की जा रही है. यहां दी गई टेबल में, हर रिकॉर्ड टाइप के लिए इस्तेमाल किए जा सकने वाले फ़ील्ड के बारे में बताया गया है:

रिकॉर्ड टाइप ब्यौरा फ़िल्टर करने के लिए इस्तेमाल किए जा सकने वाले फ़ील्ड
इंटरवल समय के साथ रिकॉर्ड किए गए डेटा पॉइंट (उदाहरण के लिए, steps, distance, calories). {dataType}.interval.start_time
{dataType}.interval.civil_start_time

उदाहरण:
steps.interval.civil_start_time
सैंपल तुरंत की गई निगरानी या कम समय में की गई मेज़रमेंट (उदाहरण के लिए, weight, body-fat, blood-glucose). {dataType}.sample_time.physical_time
{dataType}.sample_time.civil_time

उदाहरण:
body_fat.sample_time.physical_time
हर रोज़ हर दिन की मेट्रिक और खास जानकारी (उदाहरण के लिए, daily-heart-rate-variability). {dataType}.date

उदाहरण:
daily_heart_rate_variability.date
सेशन खास समय के नियमों के साथ उपयोगकर्ता सेशन को बढ़ाया गया. कसरत: {dataType}.interval.civil_start_time
नींद: sleep.interval.end_time, sleep.interval.civil_end_time
ईसीजी: electrocardiogram.interval.start_time

उदाहरण:
sleep.interval.civil_end_time

इस्तेमाल किए जा सकने वाले ऑपरेटर और फ़ॉर्मैट के नियम

फ़िल्टर एक्सप्रेशन को फ़ॉर्मैटिंग से जुड़े इन नियमों का पालन करना होगा:

तुलना करने वाले ऑपरेटर

तुलना करने वाले सिर्फ़ दो ऑपरेटर इस्तेमाल किए जा सकते हैं:

ऑपरेटर ब्यौरा
>= निचली सीमा (शामिल है).
< ऊपरी सीमा (एक्सक्लूसिव).

तुलना करने वाले अन्य ऑपरेटर (जैसे, >, <= या =) का इस्तेमाल करने पर, INVALID_DATA_POINT_FILTER_RESTRICTION_COMPARATOR के साथ 400 Bad Request दिखता है.

तार्किक ऑपरेटर

ऑपरेटर सहायता
AND यह डिफ़ॉल्ट ऑपरेटर है और सिर्फ़ इसका इस्तेमाल किया जा सकता है. इसका इस्तेमाल, शुरू और खत्म होने की सीमाओं को एक साथ जोड़ने के लिए किया जाता है.
OR समर्थित नहीं. OR का इस्तेमाल करने पर, 400 Bad Request गड़बड़ी की वजह INVALID_DATA_POINT_FILTER_EXPRESSION_STRUCTURE ("फ़िल्टर, पाबंदियों का संयोजन या क्रम होना चाहिए. DISJUNCTION" मिला).

समय की लिटरल वैल्यू

फ़िल्टर एक्सप्रेशन में समय के लिटरल के लिए, इन फ़ॉर्मैट का इस्तेमाल करना ज़रूरी है:

समय का टाइप ज़रूरी शर्तें उदाहरण
फ़िज़िकल टाइम RFC 3339 फ़ॉर्मैट में होना चाहिए. इसके आखिर में Z या यूटीसी ऑफ़सेट होना चाहिए. यह यूटीसी में असल दुनिया के इवेंट दिखाता है. सही: "2026-03-01T00:00:00Z", "2026-03-01T00:00:00-08:00"
गलत: "2026-03-01"
सिविल टाइम आईएसओ 8601 फ़ॉर्मैट: YYYY-MM-DD[THH:mm:ss]. यह उपयोगकर्ता की घड़ी में दिखने वाले समय को दिखाता है. यह जगह या टाइमज़ोन के ऑफ़सेट से अलग होता है. सही: "2026-03-01", "2026-03-01T08:30:00"

फ़िल्टर की पुष्टि करने के नियम

फ़िल्टर इन नियमों का पालन करते हैं:

नियम ब्यौरा उदाहरण
समय के अलग-अलग टाइप का इस्तेमाल नहीं किया गया है भौतिक और नागरिक समय की सीमाओं को आपस में न मिलाएं. अमान्य: steps.interval.start_time >= "2026-03-01T00:00:00Z" AND steps.interval.civil_start_time < "2026-03-02"
गड़बड़ी: INVALID_DATA_POINT_FILTER_MIXED_TIME_RESTRICTIONS ("फ़िल्टर में, फ़िज़िकल और सिविल, दोनों तरह के समय की सीमाएं नहीं हो सकतीं")
अलग-अलग डेटा टाइप का इस्तेमाल न किया गया हो अनुरोध के पाथ में, डेटा टाइप से जुड़े फ़ील्ड का इस्तेमाल करें. अमान्य: फ़िल्टर distance.interval.start_time >= "..."
वाला पाथ /users/.../dataTypes/steps/...गड़बड़ी: INVALID_DATA_POINT_FILTER_COLLECTION_MISMATCH ("फ़िल्टर में मौजूद डेटा टाइप, पैरंट डेटा टाइप कलेक्शन से मेल नहीं खाता")
समय के हिसाब से क्रम लगाने का लॉजिक ऊपरी सीमा, निचली सीमा से ज़्यादा होनी चाहिए. अमान्य: steps.interval.start_time >= "2026-03-02T00:00:00Z" AND steps.interval.start_time < "2026-03-01T00:00:00Z"
गड़बड़ी: INVALID_TIME_RANGE ("क्वेरी के खत्म होने का समय, शुरू होने के समय से ज़्यादा होना चाहिए")
केस फ़ॉर्मैट डेटा टाइप के नाम से मेल खाने वाले स्नेक केस का इस्तेमाल करें. अमान्य: body-fat.sample_time.physical_time >= "..."
गड़बड़ी: INVALID_DATA_POINT_FILTER ("अमान्य फ़िल्टर")

अमान्य फ़िल्टर के लिए, एपीआई एचटीटीपी 400 Bad Request दिखाता है. गड़बड़ी की वजह बताने वाले कोड के लिए, error.details[].metadata.detailedReasons देखें.

OAuth के ज़रूरी दायरे

फ़िल्टर का इस्तेमाल करके डेटा पॉइंट के बारे में क्वेरी करने के लिए, अनुमति वाले उपयोगकर्ता को उस डेटा टाइप के लिए, ज़रूरी OAuth स्कोप देना होगा. अगर ज़रूरी स्कोप मौजूद नहीं है, तो एपीआई 403 Forbidden स्टेटस के साथ MISSING_OAUTH_SCOPE दिखाता है.

यहां दी गई टेबल में, OAuth स्कोप को उन डेटा टाइप के साथ मैप किया गया है जिनके लिए वे रीड ऐक्सेस देते हैं. टेबल में स्कोप को उनके मिलते-जुलते फ़ॉर्मैट में दिखाया जाता है. उदाहरण के लिए, .activity_and_fitness.readonly का मतलब https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly है:

OAuth का ज़रूरी दायरा डेटा टाइप
.activity_and_fitness.readonly active-energy-burned, active-minutes, active-zone-minutes, activity-level, altitude, calories-in-heart-rate-zone, daily-vo2-max, distance, exercise, floors, run-vo2-max, sedentary-period, steps, swim-lengths-data, time-in-heart-rate-zone, total-calories, vo2-max
.ecg.readonly इलेक्ट्रोकार्डियोग्राम
.health_metrics_and_measurements.readonly ब्लड-ग्लूकोज़, शरीर-की-चर्बी, शरीर-का-औसत-तापमान, रोज़ाना-धड़कन-की-दर-में-उतार-चढ़ाव, रोज़ाना-धड़कन-की-दर-के-ज़ोन, रोज़ाना-ऑक्सीजन-की-मात्रा, रोज़ाना-सांस-की-दर, रोज़ाना-आराम-करते-समय-धड़कन-की-दर, रोज़ाना-नींद-के-दौरान-तापमान-में-बदलाव, धड़कन-की-दर, धड़कन-की-दर-में-उतार-चढ़ाव, लंबाई, ऑक्सीजन-की-मात्रा, नींद-के-दौरान-सांस-की-दर, त्वचा-के-तापमान-के-सेंसर, वज़न
.irn.readonly irregular-rhythm-notification
.nutrition.readonly food, food-measurement-unit, hydration-log, nutrition-log
.sleep.readonly नींद का डेटा

अगर आपके क्लाइंट को अनुरोध किए गए डेटा टाइप के लिए, सिर्फ़ लिखने का स्कोप (जैसे कि .activity_and_fitness.writeonly) दिया गया है, तो भी आपके पास उन डेटा पॉइंट को क्वेरी करने का विकल्प होता है जिन्हें आपके क्लाइंट ने लिखा है. इस मामले में, अनुरोधों को self-sources डेटा सोर्स फ़ैमिली के लिए सीमित कर दिया जाता है. डेटा टाइप की सीमाओं और ज़्यादा जानकारी के लिए, डेटा सोर्स फ़ैमिली के हिसाब से फ़िल्टर करना लेख पढ़ें.

इस्तेमाल के उदाहरण

यहां दिए गए उदाहरणों में, सामान्य स्थितियों के लिए फ़िल्टर बनाने का तरीका बताया गया है:

समयसीमा के हिसाब से क्वेरी के चरण

2026-03-01T00:00:00Z (शामिल है) और 2026-03-02T00:00:00Z (शामिल नहीं है) के बीच रिकॉर्ड किए गए क्वेरी चरण:

GET https://health.googleapis.com/v4/users/me/dataTypes/steps/dataPoints
  ?filter=steps.interval.start_time >= "2026-03-01T00:00:00Z"
  AND steps.interval.start_time < "2026-03-02T00:00:00Z"

सिविल टाइम रेंज के हिसाब से क्वेरी के चरण

उपयोगकर्ता की स्थानीय घड़ी के हिसाब से, 4 मार्च, 2026 को पूरे दिन के लिए क्वेरी के चरण:

GET https://health.googleapis.com/v4/users/me/dataTypes/steps/dataPoints
  ?filter=steps.interval.civil_start_time >= "2026-03-04"
  AND steps.interval.civil_start_time < "2026-03-05"

फ़िज़िकल सैंपल के समय के हिसाब से बॉडी फ़ैट के बारे में क्वेरी करना

मार्च 2026 से रिकॉर्ड की गई बॉडी फ़ैट की माप के बारे में क्वेरी करें (यूटीसी के मुताबिक):

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

सिविल सैंपल के समय के हिसाब से क्वेरी का वेट

किसी खास स्थानीय समय के बाद रिकॉर्ड किए गए क्वेरी वेट लॉग:

GET https://health.googleapis.com/v4/users/me/dataTypes/weight/dataPoints
  ?filter=weight.sample_time.civil_time >= "2026-03-01T08:00:00"

धड़कन की दर में हुए उतार-चढ़ाव की रोज़ की खास जानकारी के बारे में क्वेरी करना

किसी तारीख से पहले रिकॉर्ड की गई, धड़कन की दर में उतार-चढ़ाव (एचआरवी) की रोज़ की खास जानकारी के बारे में क्वेरी करना:

GET https://health.googleapis.com/v4/users/me/dataTypes/daily-heart-rate-variability/dataPoints
  ?filter=daily_heart_rate_variability.date < "2026-08-15"

सिविल स्टार्ट टाइम के हिसाब से, क्वेरी के लिए सेशन

उपयोगकर्ता के स्थानीय समय क्षेत्र के हिसाब से, किसी खास हफ़्ते में हुई क्वेरी के अभ्यास वाले सेशन:

GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints
  ?filter=exercise.interval.civil_start_time >= "2026-03-01"
  AND exercise.interval.civil_start_time < "2026-03-08"

नींद के सेशन की जानकारी, सेशन के खत्म होने के समय के हिसाब से क्वेरी करना

सेशन के खत्म होने के समय के हिसाब से, नींद के रिकॉर्ड के बारे में क्वेरी करना:

GET https://health.googleapis.com/v4/users/me/dataTypes/sleep/dataPoints
  ?filter=sleep.interval.civil_end_time >= "2026-03-04T05:00:00"
  AND sleep.interval.civil_end_time < "2026-03-04T12:00:00"

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

किसी यूटीसी पॉइंट से शुरू होने वाली ईसीजी रिकॉर्डिंग के बारे में क्वेरी करना. ध्यान दें कि ईसीजी क्वेरी में, सिर्फ़ >= की तुलना start_time से की जा सकती है:

GET https://health.googleapis.com/v4/users/me/dataTypes/electrocardiogram/dataPoints
  ?filter=electrocardiogram.interval.start_time >= "2026-03-10T12:00:00Z"

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

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

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

एंडपॉइंट (एचटीटीपी का तरीका) मैकेनिज़्म
list (GET) 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) के ज़रिए मैन्युअल तरीके से लॉग की गई कोई भी एंट्री शामिल है.
users/me/dataSourceFamilies/self-sources इसमें सिर्फ़ वह डेटा शामिल होता है जिसे कॉल करने वाले क्लाइंट ने Google Health API के ज़रिए लिखा है. इसमें ऐसे डेटा पॉइंट शामिल होते हैं जिनका डेटा सोर्स, एपीआई के ज़रिए रजिस्टर किया गया था. साथ ही, इसमें कॉल करने वाले क्लाइंट के OAuth क्लाइंट आईडी का इस्तेमाल किया गया था.

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

सिर्फ़ लिखने के स्कोप और खुद के सोर्स

जिन कॉलर को अनुरोध किए गए डेटा टाइप के लिए, सिर्फ़ लिखने के स्कोप (जैसे कि .activity_and_fitness.writeonly) दिए जाते हैं वे खुद लिखे गए डेटा को पढ़ सकते हैं. इसके अलावा, वे किसी और डेटा को नहीं पढ़ सकते.

  • dataSourceFamily पैरामीटर के बिना किए गए अनुरोध या dataSourceFamily को users/me/dataSourceFamilies/self-sources पर सेट करके किए गए अनुरोधों को, डिफ़ॉल्ट रूप से self-sources पर सेट किया जाता है.
  • सिर्फ़ लिखने के स्कोप के साथ, किसी अन्य डेटा सोर्स फ़ैमिली (जैसे कि all-sources, google-wearables या google-sources) का अनुरोध करने पर, 403 Forbidden (PERMISSION_DENIED) गड़बड़ी दिखती है.

सूची वाले एंडपॉइंट पर डेटा टाइप से जुड़ी सीमाएं

list एंडपॉइंट (users.dataTypes.dataPoints.list) पर, sleep, food, और food-measurement-unit डेटा टाइप के लिए, dataSourceFamily के हिसाब से फ़िल्टर करने की सुविधा उपलब्ध नहीं है:

  • sleep, food या food-measurement-unit के लिए, list पर dataSourceFamily को साफ़ तौर पर सेट करने पर, 400 Bad Request (INVALID_ARGUMENT) गड़बड़ी होती है.
  • सिर्फ़ लिखने का स्कोप दिए जाने पर, इन डेटा टाइप के लिए list को कॉल करने पर, 403 Forbidden (PERMISSION_DENIED) गड़बड़ी दिखती है. ऐसा तब होता है, जब self-sources पर पाबंदी लगाने का मतलब, कॉलर के स्कोप से होता है.
  • dataSourceFamily के हिसाब से sleep डेटा पॉइंट फ़िल्टर करने के लिए, reconcile एंडपॉइंट का इस्तेमाल करें.

डेटा सोर्स फ़ैमिली के उदाहरण

किसी उपयोगकर्ता के लिए, आपके क्लाइंट ने जो रॉ डेटा पॉइंट लिखे हैं उनकी सूची बनाने के लिए, list एंडपॉइंट को कॉल करें. साथ ही, dataSourceFamily क्वेरी पैरामीटर को users/me/dataSourceFamilies/self-sources पर सेट करें.

उदाहरण के लिए, यहां दिए गए GET अनुरोध में, 01-03-2026 से शुरू होने वाले कॉलिंग क्लाइंट के लिखे गए रॉ body-fat मेज़रमेंट की सूची दी गई है:

अनुरोध

GET https://health.googleapis.com/v4/users/me/dataTypes/body-fat/dataPoints
  ?dataSourceFamily=users/me/dataSourceFamilies/self-sources
  &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": ""
}

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

उदाहरण के लिए, यहां दिया गया GET अनुरोध, 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 फ़ील्ड पास करें.

नीचे दिए गए POST अनुरोध में, हर घंटे (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"
      }
    }
  ]
}
पीछे जाएं
एंडपॉइंट
आगे बढ़ें
कुल डेटा