# Time

> Current time and IANA timezone conversion — the first-party MCP that tells an agent what time it actually is.

[Canonical HTML page](https://top-mcps.com/mcp/time) · [server.json](https://top-mcps.com/mcp/time.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "time": {
      "command": "uvx",
      "args": [
        "mcp-server-time"
      ]
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
claude mcp add time -- uvx mcp-server-time
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "time": {
      "command": "uvx",
      "args": [
        "mcp-server-time"
      ]
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "time": {
      "command": "uvx",
      "args": [
        "mcp-server-time"
      ]
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "time": {
      "command": "uvx",
      "args": [
        "mcp-server-time"
      ]
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "time": {
      "command": "uvx",
      "args": [
        "mcp-server-time"
      ]
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "uvx",
          "args": [
            "mcp-server-time"
          ]
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.time]
command = "uvx"
args = [
  "mcp-server-time",
]
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "time": {
      "command": {
        "path": "uvx",
        "args": [
          "mcp-server-time"
        ]
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Time doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Anthropic (modelcontextprotocol)
- **Transport:** stdio
- **Auth model:** None
- **Required secrets:** None
- **Supported clients:** Claude, Claude Code, Cursor, VS Code, Zed, Any MCP-compatible client
- **License:** MIT
- **Language:** Python
- **Latest version:** latest
- **Last verified:** 2026-06-16
- **GitHub stars:** 84,102 (fetched 2026-06-17T11:53:23.212Z)
- **Score:** 96/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/modelcontextprotocol/servers/tree/main/src/time

## Tools & permissions

| Tool | Description | Args | Side effects |
|------|-------------|------|--------------|
| `get_current_time` | Get the current time in a specific IANA timezone (or the auto-detected system timezone). | `timezone?: string` | read |
| `convert_time` | Convert a 24-hour time from a source IANA timezone to a target IANA timezone. | `source_timezone: string, time: string, target_timezone: string` | read |

## Security & scope

- **Access scope:** read-only
- **Sandbox:** Local stdio process. Reads the host system clock and the bundled IANA timezone database. No filesystem writes, no network access, no credentials.
- **Gotchas:**
  - Returns the host machine clock — if the host clock is wrong, the answer is wrong. It is not an NTP time-sync service.
  - Timezone names must be valid IANA identifiers; abbreviations like "EST" or "PST" are not accepted.

## Quick answer

**What it does.** Exposes two tools — get_current_time (current time for a given IANA timezone, or the auto-detected system zone) and convert_time (convert a 24-hour time from a source IANA zone to a target zone). Timezones are passed as IANA names (e.g. America/New_York, Asia/Tokyo).

**Best for:**
- Giving an agent the current time
- Cross-timezone meeting math
- Travel arrival-time reasoning
- Stamping "now" into logs or notes
- Disambiguating "today"/"tomorrow" in scheduling

**Not for:**
- Recurring-event scheduling
- Holiday/business-hours calendars
- NTP-grade time synchronization

## Recipes

### Find a meeting slot that works across timezones

```
Use the time MCP. It is 9:00 AM in America/Los_Angeles. What time is that in Europe/Berlin and Asia/Tokyo? Then suggest a single 30-minute slot in the next few hours that falls within 9am-6pm local time for all three.
```

_Tested with: Claude Desktop, Cursor_

## Description

The Time MCP is one of the official Model Context Protocol reference servers maintained by Anthropic (modelcontextprotocol/servers). It gives an AI agent two things every location-aware or scheduling task needs: the current time in any IANA timezone, and conversion of a time from one zone to another. It runs locally over stdio with no API key, no network calls, and no account.

## Why it matters

LLMs have no built-in clock — they do not know the current time and reliably get timezone math wrong (DST boundaries, offset signs, zone abbreviations). The Time server gives the agent a ground-truth clock and correct zone conversions, which is a prerequisite for scheduling, "what time is it for the client in Tokyo," and any travel or logistics flow that reasons about local time.

## Key features

- get_current_time for any IANA timezone
- convert_time between two IANA zones
- Automatic system-timezone detection
- No API key, no network, no account
- First-party Anthropic reference server

## FAQ

### Does it need an API key or account?

No. The Time server runs locally over stdio and computes everything from the host system clock and the IANA timezone database. There is no API key, no network call, and no account to create.

### How do I tell it which timezone to use?

Pass an IANA timezone name such as America/New_York, Europe/London, or Asia/Tokyo. If you omit it, get_current_time uses the auto-detected system timezone. You can override the default at launch with the --local-timezone argument.

### Does it handle daylight saving time correctly?

Yes — conversions use the IANA timezone database, which encodes DST rules per zone. This is the main reason to use it instead of letting the model do offset arithmetic, which gets DST boundaries wrong.

### Is this an official server?

Yes. Time is one of the active first-party reference servers in the modelcontextprotocol/servers repository maintained by Anthropic, alongside Fetch, Filesystem, Git, Memory, and Sequential Thinking.

### How do I install it?

With uv installed, run uvx mcp-server-time (no separate install step). Or pip install mcp-server-time and run python -m mcp_server_time. Then add it to your client config as an stdio server.

## Changelog

- **2026-06-16** — Refreshed install snippets and fact sheet; verified for 2026.
- **2024-12-05** — Initial directory listing.