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_get_more_tools
Get more tools
Check for additional Globalping tools whenever your task might benefit from specialized capabilities : even if existing tools could work as a fallback.
Parameters
Name
Type
Required
Description
context
string
Required
A description of your goal and what kind of tool would help accomplish it.
globalpingmcp_dns
Dns
globalpingmcp_mtr
Mtr
globalpingmcp_help
Help
globalpingmcp_http
Http
globalpingmcp_ping
Ping
globalpingmcp_limits
Limits
globalpingmcp_locations
Locations
globalpingmcp_authstatus
Authstatus
globalpingmcp_traceroute
Traceroute
globalpingmcp_getmeasurement
Getmeasurement
globalpingmcp_comparelocations
Comparelocations
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 Teams
DevOps assistant agent
Polls GitHub for failing checks and stale PRs, opens Linear issues for the ones that need work, and posts a daily digest to Slack. It acts as the engineer, not a shared service account.
Engineering Teams
Slack triage
Polls Slack for new messages, classifies bugs and support requests with a LangGraph router, files GitHub issues or Zendesk tickets, and confirms in the thread.
Engineering Teams
Engineering standup agent
Pulls commits from GitHub and GitLab, tracks issue movement in Jira, and posts a per-engineer standup brief to Slack. Each engineer's activity is read on their own delegated OAuth.
Engineering Teams
Auto release notes agent
Reads merged GitHub PRs, groups them into structured release notes, publishes the page to Notion, and announces the release in Slack. Every call runs on the engineer's own delegated OAuth.
Test other agents
See the same per-user auth pattern across other monitoring connectors.
ENGINEERING
DevOps assistant agent
Poll GitHub for failing checks and stale pull requests, open Linear issues for the ones that need work, and digest to Slack.
ENGINEERING
Engineering standup agent
Pull commits from GitHub and GitLab, track Jira issue movement, and post a per-engineer standup brief to Slack.
ENGINEERING
Slack triage agent
Classify new Slack messages as bugs or support requests, file the GitHub issue or Zendesk ticket, and reply in the thread.
ENGINEERING
Auto-release notes agent
Group merged GitHub PRs into structured release notes, publish the page to Notion, and announce the release in Slack.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
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""
}
}
}