# Where to Find the Official Model Context Protocol Specification

> Find the official Model Context Protocol specification at modelcontextprotocol.io. Access the canonical JSON schema directly at modelcontextprotocol.io/spec.json.

- Repository: [Frank Fiegel/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
- Tags: api-reference
- Published: 2026-09-04

---

**The official Model Context Protocol specification is hosted at modelcontextprotocol.io, with the canonical JSON schema available at modelcontextprotocol.io/spec.json.**

Developers building integrations with the **Model Context Protocol** require access to the authoritative specification to ensure compatibility and security. The **punkpeye/awesome-mcp-servers** repository serves as a curated index of MCP implementations and links directly to the official specification source. Understanding where to locate this documentation is essential for anyone developing MCP servers or clients.

## Official Model Context Protocol Specification Website

The canonical source for the **Model Context Protocol specification** resides at **https://modelcontextprotocol.io/**. According to the `punkpeye/awesome-mcp-servers` source code, MCP is defined in [`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md) lines 29-30 as "an open protocol that enables AI models to securely interact with local and remote resources through standardized server implementations"【/cache/repos/github.com/punkpeye/awesome-mcp-servers/main/README.md†L29-L30】.

The website provides two primary resources:

- **Specification overview**: The human-readable documentation at https://modelcontextprotocol.io/ describing the protocol's data model, RPC schema, and security model.
- **Machine-readable schema**: The JSON schema at https://modelcontextprotocol.io/spec.json for programmatic validation and code generation.

## Accessing the MCP Specification Programmatically

For automated tooling and client development, you can retrieve the specification directly via HTTP requests.

### Fetch the Specification with cURL

Use command-line tools to quickly retrieve the schema:

```bash
curl -s https://modelcontextprotocol.io/spec.json | jq .

```

This command downloads the JSON schema and pipes it through `jq` for formatted reading, displaying the protocol's structure including methods and types.

### Load the Specification in Python

For Python applications, use the `requests` library to fetch and inspect the schema:

```python
import requests, json

spec_url = "https://modelcontextprotocol.io/spec.json"
spec = requests.get(spec_url).json()

# Print top-level keys (e.g., methods, types)

print(spec.keys())

```

This approach enables dynamic schema validation or documentation generation within Python-based MCP tools.

### Use the Specification in TypeScript

TypeScript and Node.js applications can import the specification for type checking:

```ts
import fetch from "node-fetch";

async function loadMcpSpec() {
  const res = await fetch("https://modelcontextprotocol.io/spec.json");
  const spec = await res.json();
  console.log(Object.keys(spec));
}
loadMcpSpec();

```

This pattern supports building strongly-typed MCP clients that stay synchronized with protocol updates.

## Locating the Specification in the Repository

The **punkpeye/awesome-mcp-servers** repository maintains the official specification link in its documentation files. In [`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md) lines 29-30, the repository explicitly links to modelcontextprotocol.io as the authoritative source【/cache/repos/github.com/punkpeye/awesome-mcp-servers/main/README.md†L29-L30】.

Additional documentation files in the repository include:

- **[`CONTRIBUTING.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/CONTRIBUTING.md)**: Guidelines for adding new MCP servers to the curated list.
- **[`README-zh.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README-zh.md)**: Chinese translation of the main documentation, also referencing the official spec.
- **`LICENSE`**: The MIT license governing the repository content.

These files collectively serve as the entry point for developers discovering MCP resources.

## Summary

- The **Model Context Protocol specification** is officially hosted at **modelcontextprotocol.io**.
- The machine-readable **JSON schema** is available at **modelcontextprotocol.io/spec.json**.
- The **punkpeye/awesome-mcp-servers** repository links to the official spec in [`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md) lines 29-30.
- Developers can programmatically fetch the specification using **cURL**, **Python**, or **TypeScript** for automated tooling.

## Frequently Asked Questions

### What is the official URL for the Model Context Protocol specification?

The official **Model Context Protocol specification** is located at https://modelcontextprotocol.io/. This website contains the complete protocol documentation including the data model, RPC schema, and security requirements for implementing MCP servers and clients.

### Is there a machine-readable version of the MCP specification?

Yes. The **JSON schema** is available at https://modelcontextprotocol.io/spec.json. This machine-readable format enables automated code generation, schema validation, and dynamic client configuration without manual parsing of HTML documentation.

### Where does the awesome-mcp-servers repository reference the official spec?

The repository references the official specification in **[`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md)** at lines 29-30, where it defines MCP and provides the canonical link to modelcontextprotocol.io. This serves as the primary entry point for developers browsing the curated server list.

### What is the Model Context Protocol used for?

According to the repository's [`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md), MCP is "an open protocol that enables AI models to securely interact with local and remote resources through standardized server implementations." It provides a standardized way for AI systems to access tools, data sources, and computational resources.