Globalping MCP

Live

API KEY

NETWORK MONITORING

Monitoring

Globalping MCP gives agents network monitoring from hundreds of real probes: ping, traceroute, DNS, HTTP, and MTR, each run on the user's own API key.

  • Per-user credentials: each call uses the actual user's token, never a shared bot.
  • Encrypted per-tenant vault: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: pre-call scope check, 90-day SIEM-exportable audit chain.
Globalping MCP
agent · Acme Q3
Run
Is api.example.com slow from Asia right now?
S
globalpingmcp_ping
104ms
Network agent
Pinged from 8 Asian probes. Avg 41ms: Tokyo 28ms, Singapore 35ms, Mumbai 89ms with 2% packet loss. No outage detected.
Sources: 8 probes, 4 countries, last 5 min
globalpingmcp
8 probes
18:29
Message Claude...

Tools your ops agent reaches for on Globalping, scoped per user.

CALL ANY TOOL
Network monitoring from real vantage points: measure latency, trace routes, resolve DNS, and probe HTTP from hundreds of global locations.
globalpingmcp_ping
Ping a target
Measure latency, packet loss, and reachability to a public domain or IP from globally distributed probes.
Parameters
Name
Type
Required
Description
context
string
Required
Explain why you are calling this tool and how it fits into the user's overall goal. Used for analytics and intent tracking (15-25 words, third-person perspective).
target
string
Required
Public domain name or IP address to test (e.g., 'google.com', '1.1.1.1'). Private IPs (RFC1918), localhost, and link-local addresses are not supported.
limit
number
Optional
Number of probes to use (default: 3, max: 100).
locations
string
Optional
Locations to run the test from. Supports Globalping magic field syntax: 'world', country codes like 'US', city names like 'London+UK', ASNs like 'AS13335', or cloud regions like 'Amazon+Germany'. Can also be a previous measurement ID to compare from the same probes.
packets
number
Optional
Number of packets to send (default: 3).
globalpingmcp_traceroute
Trace a route
globalpingmcp_mtr
Run MTR
globalpingmcp_dns
Resolve DNS
globalpingmcp_http
Probe HTTP
globalpingmcp_getmeasurement
Fetch measurement details
globalpingmcp_limits
Check rate limits
Build your Agent
Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Globalping tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["globalpingmcp"], toolNames: [
    "globalpingmcp_ping",
    "globalpingmcp_traceroute",
    "globalpingmcp_http"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Ping api.example.com from 10 probes across Europe." }] });
import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["globalpingmcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Is our site reachable from Singapore right now?" }],
  tools,
});

// Execute the tool call with the user's vaulted Globalping key
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");
import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["globalpingmcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Run an MTR to our API and flag hops with packet loss." }],
  tools,
});

// Tool call runs with the user's vaulted Globalping key
await sk.tools.executeTool(msg.content, "user_123");
import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["globalpingmcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "network_diag_agent",
  model: "gemini-2.5-pro",
  instruction: "Run global network measurements for the signed-in user.",
  tools,
});

await agent.run("Check HTTP response times for example.com from 10 global probes.");
Try these prompts
Copy any prompt into your agent. Each maps directly to a Globalping tool. Click to copy, paste into your agent, done.
Check reachability
Copy the prompt
Copied
Ping api.example.com from 10 probes across Europe.
Copy the prompt
Copied
Is our site reachable from Singapore right now?
Copy the prompt
Copied
Compare latency to our origin from US East and US West.
Debug routing
Copy the prompt
Copied
Traceroute to cdn.example.com from Sao Paulo.
Copy the prompt
Copied
Run an MTR to our API and flag hops with packet loss.
Copy the prompt
Copied
Where along the path do packets drop for users in Sydney?
Verify DNS and HTTP
Copy the prompt
Copied
Has the new A record propagated in Asia yet?
Copy the prompt
Copied
Check TTFB for example.com from 8 global locations.
Copy the prompt
Copied
Verify the www CNAME resolves correctly from Germany.
SEE HOW AUTH WORKS
Your users connect once. Their Globalping keys stay vaulted, every call is scope-checked, and every action is logged.
1
Authorize
Your user connects
Globalping MCP
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
Globalping MCP
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
Globalping MCP
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
Globalping MCP
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
See the same per-user auth pattern across other monitoring connectors.
ENGINEERING
DevOps assistant agent
Triage GitHub incidents, open Linear tickets, and notify the on-call channel in Slack with context already attached.
ENGINEERING
Engineering standup agent
Aggregate GitHub and GitLab activity, link to Jira, and post a daily standup digest to Slack. No async updates.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
Other connector libraries treat auth as a demo afterthought. Scalekit starts with identity, scope enforcement, and audit. Connectors follow.
01.
Shared tokens break per-user analytics
A shared Globalping key looks fine in a demo. In production every measurement draws from one quota, and you cannot tell whose debugging session burned the credits. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.
// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
Globalping today. Others tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions
Does the agent access Globalping as the user or through a shared key?
As the user. Scalekit resolves the credential of the person who triggered the agent at request time, so every ping, traceroute, and HTTP probe in your audit trail is attributed to a real user, not a shared service account.
Where is the Globalping key stored?
In an AES-256 encrypted vault with per-tenant namespacing. Keys are resolved at request time, never enter LLM context, and can be rotated or revoked from one dashboard.
Can I limit what the agent does in Globalping?
Yes. Filter by tool name in listScopedTools to expose only what you want, for example ping and DNS without HTTP probes. Scalekit also enforces scope checks before every API call.
What happens when a user revokes access?
The credential is invalidated at the next tool call. The call fails closed, other users' connections are unaffected, and the revocation is logged in the audit chain.
How do I keep an agent from burning through Globalping rate limits?
Two layers. The connector's limits tool reports remaining credits so the agent can check quota before queuing measurements, and because each user runs on their own vaulted key, one user's probe storm never consumes a teammate's allowance.
Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""globalpingmcp"": {
""url"": ""https://mcp.scalekit.com/globalpingmcp"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.globalpingmcp]
url = ""https://mcp.scalekit.com/globalpingmcp""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""globalpingmcp"": {
""url"": ""https://mcp.scalekit.com/globalpingmcp"",
""type"": ""http""
}
}
}