# UptimeScout API: Regional Service Availability for Your Apps and AI

https://jsonscraper.com/blog/uptimescout-regional-api-launch

Author: Michael Johnson

Published: 2026-11-19T15:24:18+00:00

Updated: 2026-11-19T15:24:18+00:00

Introducing the API on jsonscraper: REST, MCP, and six ready-to-use SDKs. Check external dependencies from the country you need — start for free.

![UptimeScout — Service availability monitoring](https://jsonscraper.com/assets/img/uptimescout-launch/cover-v8-en.webp)

When an external platform stops responding, it quickly becomes your problem: authentication fails, an integration hangs, and the support queue grows. At the same time, the same service can look different to users in different countries. A general status of “everything is working” is not enough in this situation.



We’re launching [UptimeScout API on jsonscraper](https://jsonscraper.com/services/uptimescout-api?region=RU). It gives your apps and AI assistants regional availability signals for external services—with history, observation times, and an explicit indication of data freshness. REST, MCP, and SDKs for six languages are available now. You can start with a free plan.

 

## Check a service from the country you need



For a support team, one simple question matters: what is happening with the service where the user is located? UptimeScout lets you select a country, get the current signal, and compare it with observations from other regions.



For example, you can check GitHub for Russia and Germany, then open the history for the available period. This adds context to your own logs and helps you choose the next step in an investigation. In a verified API response dated November 19, 2026, 72 regions were available. Check `available_regions` for current coverage: it can differ between services.



Each response includes the observation time, `observed_at`, and a staleness indicator, `stale`. The description language is selected independently of the country: you can get observations for Japan with descriptions in Russian or English. A total of 20 description languages are supported.



> A regional signal can help you spot a problem. It does not establish its cause or confirm a global outage. For investigations, compare it with your own checks and the provider’s official status; observation statistics are not an uptime or SLA measurement.

 

## Explore the observations map



Select a country or find the service you need. Switch between the globe and map to see regional differences and the times of the latest observations.



[Interactive regional observations](https://jsonscraper.com/services/uptimescout-api#regions). Live observations are separate from the historical examples in this article.



The map shows a saved data snapshot that is refreshed in the background approximately once a minute. The observation time remains visible: if there is no fresh data, the status cannot be considered confirmed.

 

## Turn an external signal into a useful action



Add UptimeScout to the workflow your team already uses. On a dashboard, it provides context about external dependencies. For support, it helps check a report from a specific country. In an automation workflow, it can provide data for your own report or notification.



![Conceptual illustration: regional observations combine into a structured API response](https://jsonscraper.com/assets/img/uptimescout-launch/regions-v2.webp)

Regional context for your integrations. Conceptual illustration, not real measurements.



1. 01
   
   **Choose the context**
   
   The service you need and your audience’s country.
2. 02
   
   **Check the observation**
   
   Status, time, and data freshness in a single response.
3. 03
   
   **Use the result**
   
   In a dashboard, support workflow, or AI assistant.



Use a batch request for multiple dependencies. To compare countries, make a separate request for each region. Before sending an alarming notification to users, verify the signal using additional sources.

 

## One API for three tasks



### Find a service



`/v1/services` — search the catalog. Start here to choose the dependency you need.



### Understand the current picture



`/v1/status` returns a signal for one service, `/v1/statuses` returns signals for several at once, and `/v1/summary` provides a summary.



### Review changes



`/v1/history` provides history, `/v1/stats` provides observation statistics, and `/v1/incidents` provides recent elevated problem signals.



All seven methods are also available through MCP—for example, `uptimescout_status` and `uptimescout_history`. Full parameters are listed in the [OpenAPI specification](https://uptimescout.com/openapi.json).

 

## Make your first request in minutes



Choose the [free plan](https://jsonscraper.com/services/uptimescout-api#pricing), get a license key through Evelode, and save it on your server as `UPTIMESCOUT_LICENSE_KEY`. One key works with REST, MCP, and all UptimeScout SDKs.



```bash
curl --get 'https://api.uptimescout.com/v1/status' \
  --header "Authorization: Bearer $UPTIMESCOUT_LICENSE_KEY" \
  --data-urlencode 'service=github' \
  --data-urlencode 'region=RU' \
  --data-urlencode 'lang=ru'
```



If you work with Python, install the ready-to-use client from the GitHub release:



```bash
python -m pip install "git+https://github.com/jsonscraper/uptimescout-api-python.git@0.1.3"
```



```python
import os
from uptimescout import Client

client = Client(os.environ["UPTIMESCOUT_LICENSE_KEY"], timeout=30)
response = client.status("github", region="RU", lang="ru")
service = response["service"]
print(service["status"], service["observed_at"], service["stale"])
```



In addition to [Python](https://github.com/jsonscraper/uptimescout-api-python), SDKs are available for [Node.js](https://github.com/jsonscraper/uptimescout-api-node), [PHP](https://github.com/jsonscraper/uptimescout-api-php), [Go](https://github.com/jsonscraper/uptimescout-api-go), [Java](https://github.com/jsonscraper/uptimescout-api-java), and [.NET](https://github.com/jsonscraper/uptimescout-api-dotnet). Each repository includes instructions and request examples.



When processing a response, distinguish between two fields: the top-level `status` describes the API request, while `service.status` is the signal for the selected service. When reporting the result, take the country, observation time, and `stale` into account.

 

## What the response contains



Below is a shortened real UptimeScout response for GitHub in Russia, received on November 19, 2026. This is an example of the data structure, not the service's current status; license and quota usage fields are omitted.



GET /v1/statusJSON · RU



```json
{
  "status": "ok",
  "region": "RU",
  "service": {
    "id": "github",
    "name": "GitHub",
    "status": "operational",
    "stale": false,
    "observed_at": "2026-11-19T13:46:49.188257Z",
    "signal": "reported_availability",
    "scope": "regional"
  },
  "generated_at": "2026-11-19T13:48:48.782598Z",
  "stale_after_seconds": 600
}
```



**`service.status`**


The selected service's signal; here, it is operational.



**`region`**


The country where the observation was made, not the response language.



**`observed_at`**


The time of the observation in UTC.



**`stale`**


Indicates whether the observation is already stale.



The `generated_at` field shows when the response was generated. It does not replace `observed_at`: the data may be older than the response itself.

 

## The same API in a conversation with an assistant



If you’d rather start without writing your own code, connect `https://mcp.uptimescout.com` to a compatible AI client. The [MCP instructions](https://mcp.uptimescout.com/connect?ui_locales=en) describe authorization through Evelode or a license key. The [jsonscraper universal connector](https://jsonscraper.com/services/uptimescout-api#connect) is also available.



> “Check GitHub in Russia and Germany. Give the observation time and data freshness for each country. If the signals differ, explain what is known and which checks to do next.”



The assistant will receive structured API data and can explain the result in the context of your task. The limitations around freshness and regional coverage still apply.

 

## Three ways to connect to the same data



Choose the interface that suits you. REST is suitable for direct HTTP requests, an SDK for an application, and MCP for an AI assistant. The region, observation freshness, and meaning of statuses remain the same in all cases.



![UptimeScout](https://jsonscraper.com/assets/img/uptimescout-launch/uptimescout-logo.svg)

**UptimeScout API**Service · country · observation time



- **REST**Direct HTTP requests
- **SDK**Ready-to-use client for an application
- **MCP**AI assistant tools

 

## A free start with clear limits



The Free plan includes **1,000 successful requests per license period**, up to **60 requests per minute**, up to **5 services in one batch**, and **7 days** of history. You can try REST, SDKs, and MCP with one license.



A successful batch within the plan limit consumes one request. Each subsequent history page counts as a separate call. The quota is tied to the license period and resets upon renewal or a plan change—not on the first day of the month. History includes only periods for which observations were actually collected.



This is enough to explore the API and build a prototype. For ongoing monitoring, match your request frequency to the quota; Starter, Builder, Pro, and Scale plans are available for heavier workloads. Current terms are published on the [pricing page](https://jsonscraper.com/services/uptimescout-api#pricing).

 

## Start with one dependency



Choose a service that matters to your product and the country where your audience is located. Explore the map, make your first request, and see how regional context can help your team. Then add history, other dependencies, or your own AI assistant.



**[Open UptimeScout API and start for free →](https://jsonscraper.com/services/uptimescout-api?region=RU)**
