About SpeedOf.Me
SpeedOf.Me’s MCP server lets AI agents run live internet speed tests and read results, for users checking connection quality. It also provides local test history and configuration resources, and is available as a CLI and Node SDK.
Key features
- 01Run live download and upload tests
- 02Measure latency and jitter
- 03Read local test history
- 04Expose history and configuration resources
- 05Use as a standalone CLI or Node SDK
Use cases
- 01Check current internet connection speed
- 02Compare results from different times
- 03Run speed tests from scripts
- 04Let an agent query network performance
MCP support
The MCP server provides clients with live speed-test and history tools, plus resources for recent results and current configuration. It uses stdio and requires a SpeedOf.Me API secret.
Configuration
Local server config is the same for every client. Copy it into your client’s MCP config file.
npx -y @speedofme/mcpSOM_API_SECRETSecretYour SpeedOf.Me API secret from https://speedof.me/api/portal/settings.phpLocal servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.
Tools
2Saved tool list · updated 3w ago
| Parameter | Type | Required | Description |
|---|---|---|---|
| tests | array | No | Which tests to run. Default: all (latency, download, upload) |
| sustainTime | number | No | How long to sustain each download sample (1-8 seconds). Lower = faster but less accurate, higher = slower but more accurate. Default: 6 |
| testTimeout | number | No | Overall wall clock cap for the whole test in seconds. 0 disables, below 30 raised to 30, above 1800 lowered to 1800. Default: 300 |
Details
From the project READMESpeedOf.Me MCP Server
Official MCP server for SpeedOf.Me. Lets an AI agent run a real internet speed test and read the result: download, upload, latency and jitter, measured against 130+ global edge servers.
"How fast is my connection right now?"
→ 187.4 Mbps down / 41.2 Mbps up / 11 ms latency / 1.8 ms jitter (San Jose)
Tools
| Tool | What it does |
|---|---|
run_speed_test | Runs a live speed test and returns download, upload, latency and jitter |
get_test_history | Returns previous results from local history |
| Resource | Contents |
|---|---|
speedofme://history | Recent test results (JSON) |
speedofme://config | Current configuration and status |
Quick start
1. Get a free API secret
Register, then open Integrations and generate a secret.
2. Add the server to your MCP client
{
"mcpServers": {
"speedofme": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@speedofme/mcp"],
"env": {
"SOM_API_SECRET": "SOM_SECRET_xxx"
}
}
}
}
Claude Code, one command:
claude mcp add speedofme --env SOM_API_SECRET=SOM_SECRET_xxx -- npx -y @speedofme/mcp
VS Code (Copilot) uses servers instead of mcpServers in .vscode/mcp.json; the rest of the
block is identical. Cursor, Windsurf, Zed, Cline, Continue, JetBrains and Goose all take the JSON
above. Client-specific configs and agent-framework examples (LangChain, LlamaIndex, AutoGen,
CrewAI, Semantic Kernel) are in the
integration docs.
3. Restart the client and ask for a speed test.
Tool reference
run_speed_test
| Parameter | Type | Default | Description |
|---|---|---|---|
tests | string[] | all | Which tests to run: download, upload, latency |
sustainTime | number | 6 | Seconds to sustain each sample (1-8). Lower is faster, higher is more accurate |
testTimeout | number | 300 | Wall-clock cap for the whole run, in seconds. 0 disables, min 30, max 1800 |
The tool replies with formatted text. The underlying result looks like this:
{
"testId": "abc123",
"download": 150.5,
"upload": 45.2,
"latency": 12,
"jitter": 2.3,
"testServer": "San Jose",
"timestamp": "2026-08-18T10:30:00Z"
}
Speeds are Mbps, latency and jitter are milliseconds.
get_test_history
| Parameter | Type | Default | Description |
|---|---|---|---|
limit | number | 10 | Maximum number of results |
since | string | none | ISO date string. Only results after this time |
History is stored locally in ~/.speedofme/history.json, capped at 1 MB (roughly 2,600 results).
Also a CLI
The same package runs standalone, no MCP client required:
SOM_API_SECRET=SOM_SECRET_xxx npx -y @speedofme/mcp --progress # human readable
SOM_API_SECRET=SOM_SECRET_xxx npx -y @speedofme/mcp --json # for scripts
npx -y @speedofme/mcp history --limit 5 # past results
npx -y @speedofme/mcp --help
And as a Node SDK:
const { SpeedTest } = require('@speedofme/mcp');
const test = new SpeedTest({ apiSecret: process.env.SOM_API_SECRET });
const result = await test.run(); // { download, upload, latency, jitter, ... }
Full CLI and SDK options are documented on npm.
How the measurement works
SpeedOf.Me has measured what we call Real-World Speed the same way since 2011. Rather than blasting a fixed payload, the test downloads progressively larger samples, starting at 128 KB, until one takes longer than the sustain time (6 seconds by default), and reports the rate of that final sample. Upload works the same way in reverse, and latency and jitter come from 10 round-trip samples. Tests run against the nearest of 130+ edge locations, so an agent gets the same number a person would see in the browser.
Every test also lands in your dashboard with geographic, device and platform breakdowns, and usage against your plan.
Details: how it works.
Requirements
- Node.js 18 or newer
- A SpeedOf.Me API account and secret (free tier available)
About this repository
This repo is the home of the MCP server: documentation, the registry entry (server.json) and
the issue tracker. The server itself is distributed as the
@speedofme/mcp npm package and its source is not
published here.
Found a bug or want a tool added? Open an issue, or email [email protected].
Links
License
The @speedofme/mcp package is proprietary software of Speed of Me, LLC. Unauthorized copying or
redistribution is prohibited. The documentation in this repository is provided for use with the
SpeedOf.Me API.
Comments
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.