# Checking a Regional Signal: How to Compare Service Status with UptimeScout History

https://jsonscraper.com/blog/check-regional-service-status-uptimescout-history

Author: Michael Johnson

Published: 2026-11-21T11:34:42+00:00

Updated: 2026-11-21T11:34:42+00:00

Request regional observations and history, check timestamps and freshness, then compare them with your application logs.

To check whether a suspected outage matches observations in a specific region, request the service status and history for a selected time window. Compare the region and timestamps with your application logs. The result answers a specific question: is a regional signal recorded in the stored data, and how fresh is the corresponding record?

 

The [UptimeScout specification](https://uptimescout.com/openapi.json) describes separate status and history methods. In a status response, the top-level `status` field reports the result of the API request; the service signal is in `service.status`. History contains aggregated time intervals, resolution, and sample counts. These are useful data for initial diagnosis and as an attachment to an incident report.

 

## 1. Prepare the service, region, and license

 

The example below uses the service ID `github` and region `US`. For your check, use a valid ID from the UptimeScout catalog and the code for the region where the issue was observed. Available regions may vary by service; check `available_regions` in the response before interpreting the results.



![Article: Checking a Regional Signal: How to Compare Service Status with UptimeScout
Summary: A step-by-step guide to diagnosing a UptimeScout regional signal: make requests with the Python SDK, check `service.status`, `observed_at`, and `stale`, then review the history and its resolution.
Image role: cover — the central idea
Section: 1. Prepare the service, region, and license
Visual subject: Editorial photo illustration, close tabletop view of an incident response worksheet: a US regional map beside two n](https://jsonscraper.com/assets/uploads/journal/2026/11/392a4a61d4ab1c47ecbb56def0285127.png.hero.webp)

A region on the map is compared with timestamps and gaps in the observation history.© jsonscraper · AI-generated

 

Install Python 3.10+ and the SDK following the project instructions. Set the key in the `UPTIMESCOUT_LICENSE_KEY` environment variable; do not put it in code or logs. The example makes two requests through the documented client, keeps the original JSON responses in memory, and prints them for inspection. This is an integration example, not a report of a test performed here.

 

```
import json
import os
from uptimescout import Client, UptimeScoutError

client = Client(os.environ["UPTIMESCOUT_LICENSE_KEY"], timeout=30)

try:
    status_data = client.status("github", region="US", lang="ru")
    history_data = client.history("github", region="US", hours=24, lang="ru")
except UptimeScoutError as error:
    raise SystemExit(f"API request failed: HTTP {error.status}")

print(json.dumps(
    {"status": status_data, "history": history_data},
    ensure_ascii=False,
    indent=2,
))
```

 

The official [UptimeScout Python SDK](https://github.com/jsonscraper/uptimescout-api-python) documents the client, the `status` and `history` methods, and the Bearer authentication it handles behind the scenes. Follow the repository's current instructions for installation and versions; the snippet assumes the SDK is installed.

 

## 2. Make sure you are reading the signal, not the request status

 

Check the response fields `service.status`, `service.observed_at`, `service.stale`, and the response region. The top-level `status` refers to whether the API request succeeded, not to the availability of the service itself. Also record the request time, service ID, and region parameters so it is clear which record the output refers to.

 

If the observation is marked as fresh and `service.status` indicates degradation or an outage, record it as a regional signal and compare it with your own logs, connection errors, and application checks. The `stale` field indicates whether the stored observation has exceeded the defined freshness window. If it is `true` or the required field is missing, mark current availability as unknown based on this response; do not turn a stale or incomplete record into a claim about the current state.

 

UptimeScout describes the data as stored regional signals: they are a diagnostic reference, not a direct uptime measurement or confirmation of a global outage. So report the result precisely: “a signal of this type was found for this region, recorded at the specified time.” Comparing it with your own checks will show whether this external signal aligns with your application's users' experience.

 

## 3. Compare the history and interval resolution

 

The history method returns time aggregates. Check `resolution_seconds`, `samples`, `counts`, and `effective_start` in the response; also keep the actual time boundaries of the intervals. The documentation describes alignment to UTC: three-minute intervals for windows up to an hour, five-minute intervals for up to three hours, hourly intervals for up to a day, and daily intervals for longer windows. Older stored aggregates may retain a coarser stated resolution.



![Article: Checking a Regional Signal: How to Compare Service Status with UptimeScout
Summary: A step-by-step guide to diagnosing a UptimeScout regional signal: make requests with the Python SDK, check `service.status`, `observed_at`, and `stale`, then review the history and its resolution.
Image role: supporting illustration 2 — a different specific aspect
Section: 3. Compare the history and interval resolution
Visual subject: A clean editorial infographic on a light background, four sequential panels showin](https://jsonscraper.com/assets/uploads/journal/2026/11/fc10679b2a9f2c60c9aa8ec3f7f897a6.png.hero.webp)

Response fields and the steps for checking a regional signal and its history.© jsonscraper · AI-generated illustration

 

So choose a window that fits the question. For a short incident, use an appropriate short range and show the resolution alongside the result. For a long period, note that the history may be aggregated by day: a daily point cannot reconstruct minute-by-minute changes.

 

Missing intervals are unknown data, not evidence of normal operation. Keep the sample count and interval boundaries alongside aggregated values. This helps show how completely the history covers the period under investigation and what data the conclusion is based on.

 

## 4. Prepare a verifiable incident record

 

For a report, save the original responses and normalized fields: service, region, request time, `service.status`, `observed_at`, `stale`, selected history window, `resolution_seconds`, sample count, and `effective_start`. Leave missing values missing: zero and no data have different meanings.

 

Then compare these details with internal checks for the same period: response codes, connection errors, hosting region, and timestamps. If the data differ, preserve both sides. A UptimeScout regional observation and a check of a specific endpoint describe different observation points, so a discrepancy calls for investigation rather than choosing whichever result is more convenient.

 

For an API error, use the HTTP code as a guide: the specification lists invalid parameters, missing license, invalid license, quota exceeded, and temporary unavailability. Address the corresponding cause. A request error is not the status of the service being checked.

 

## What to give the on-call responder

 

In the brief summary, include the service, region, observation time, record freshness, and history resolution. Mark intervals without data as unknown and attach internal logs for the matching period. This gives the team a verifiable regional signal without conflating the API request status, UptimeScout observations, and your application's own measurements.
