Koskamo

GetSize MCP

An official MCP server provided by GetSize AB that enables AI agents and e-commerce platforms to integrate accurate shoe size recommendations. It leverages real-world fit data and brand-specific size charts to help users find the correct size across different brands without needing to measure their feet.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

GetSize MCP logo, by GetSize ABVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-08Operated by GetSize AB
MCP endpoint (Streamable HTTP)
https://www.getsize.shoes/mcp
Vendor documentation

What its tools do

8 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (3)

Can change data (5)

8 of 8 have a description · 8 of 8 declare behavior hints · 7 of 7 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to getsize.shoes ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Recommend shoe sizes for specific brands based on user's existing footwear
  • Compare fit across different brands like Nike and Adidas
  • Convert between EU, US, and UK sizing systems
  • Embed size recommendations into AI chatbots or shopping experiences

Source and maintenance

Vendor evidenceRegistry 1.0.0
mcp-registry: shoes.getsize/getsize@1.0.0Project website

Protocol and capabilities

Server
getsize 1.0.0
MCP protocol negotiated in check
2025-06-18
Tools
8 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

GetSize finds the right shoe size across brands. Start with start_session, then ask which shoes the person already owns and fit well: the recommendation is built from those rather than from a measurement, and one good shoe is worth more than a guess. Identify every shoe with find_shoe before adding it. Sizes come from the brand's published size chart — for the exact model where one exists, otherwise the brand's general chart — so say which shoe an answer came from.

Tools

8 advertised

start_session — Start a sizing session
Advertised by the server during the last successful anonymous check.

Call this first, once per conversation. Returns a session id that every other tool needs. No personal data is required and none is asked for.

start_session input schema
{
  "type": "object",
  "required": [],
  "properties": {},
  "additionalProperties": false
}
start_session annotations
{
  "title": "Start a sizing session",
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
find_shoe — Find a shoe in the catalogue
Advertised by the server during the last successful anonymous check.
Advertised read-only

Identifies a shoe one answer at a time. Call it with no answers to get the list of brands, then again with each answer appended: brand, then model, then colourway, then size. It replies with the next question and the answers allowed, until the shoe is identified. Append each option's id, not the name shown beside it: the name is for the person, the id is the answer. Always work through this rather than guessing, because only the answers it offers exist and a shoe we do not hold cannot be sized.

find_shoe input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "answers": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The answers so far, in order. Each is the id of an option the previous call offered. Empty or omitted to start."
    },
    "purpose": {
      "enum": [
        "own",
        "considering"
      ],
      "type": "string",
      "description": "What the shoe is for. A shoe they own needs a size, so the walk asks for one. A shoe they are considering does not, because working the size out is the point, and that walk finishes a step earlier."
    }
  },
  "additionalProperties": false
}
find_shoe annotations
{
  "title": "Find a shoe in the catalogue",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
add_shoe — Record a shoe the person already owns
Advertised by the server during the last successful anonymous check.

Records a shoe the person owns and the size they wear in it. This is what every recommendation is built from, so ask for at least one shoe that fits them well before calling recommend_size. Use find_shoe first to get the identifiers.

add_shoe input schema
{
  "type": "object",
  "required": [
    "sessionId",
    "answers"
  ],
  "properties": {
    "answers": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The complete set of answers from find_shoe, including the size they wear. find_shoe says when it is complete."
    },
    "sessionId": {
      "type": "string",
      "description": "The session id returned by start_session. Everything the person tells you is stored against it, and it is the only thing linking one call to the next."
    }
  },
  "additionalProperties": false
}
add_shoe annotations
{
  "title": "Record a shoe the person already owns",
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
list_shoes — List the shoes in this session
Advertised by the server during the last successful anonymous check.
Advertised read-only

Shows what the person has told us they own, with the id needed to remove one or to record how it fits.

list_shoes input schema
{
  "type": "object",
  "required": [
    "sessionId"
  ],
  "properties": {
    "sessionId": {
      "type": "string",
      "description": "The session id returned by start_session. Everything the person tells you is stored against it, and it is the only thing linking one call to the next."
    }
  },
  "additionalProperties": false
}
list_shoes annotations
{
  "title": "List the shoes in this session",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
remove_shoe — Remove a shoe from this session
Advertised by the server during the last successful anonymous check.
Advertised destructive

Removes a shoe the person no longer wants counted, using the id from list_shoes. Anything they said about how it fits goes with it.

remove_shoe input schema
{
  "type": "object",
  "required": [
    "sessionId",
    "shoeId"
  ],
  "properties": {
    "shoeId": {
      "type": "integer",
      "description": "The id from list_shoes."
    },
    "sessionId": {
      "type": "string",
      "description": "The session id returned by start_session. Everything the person tells you is stored against it, and it is the only thing linking one call to the next."
    }
  },
  "additionalProperties": false
}
remove_shoe annotations
{
  "title": "Remove a shoe from this session",
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": true
}
set_foot_measurement — Record a measured foot length
Advertised by the server during the last successful anonymous check.

Records the length of the person's foot in millimetres, heel to longest toe. More precise than a shoe they own, and worth asking for when they have no shoes to give or the answer matters. A measurement and owned shoes can both be present.

set_foot_measurement input schema
{
  "type": "object",
  "required": [
    "sessionId",
    "lengthMm"
  ],
  "properties": {
    "lengthMm": {
      "type": "integer",
      "description": "Foot length in millimetres. A typical adult is between 220 and 320."
    },
    "sessionId": {
      "type": "string",
      "description": "The session id returned by start_session. Everything the person tells you is stored against it, and it is the only thing linking one call to the next."
    }
  },
  "additionalProperties": false
}
set_foot_measurement annotations
{
  "title": "Record a measured foot length",
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
rate_fit — Record how a shoe actually fits
Advertised by the server during the last successful anonymous check.

Records what the person says about wearing a shoe they own: whether it is the right length and width. This is the most valuable thing they can tell us, because it is the difference between what the chart says and what happened. Use the shoe id from list_shoes.

rate_fit input schema
{
  "type": "object",
  "required": [
    "sessionId",
    "shoeId",
    "dimension",
    "verdict"
  ],
  "properties": {
    "shoeId": {
      "type": "integer",
      "description": "The id from list_shoes."
    },
    "verdict": {
      "enum": [
        "TOO_SMALL",
        "PERFECT",
        "TOO_LARGE"
      ],
      "type": "string",
      "description": "What they said. PERFECT means they would buy it again."
    },
    "dimension": {
      "enum": [
        "LENGTH",
        "WIDTH"
      ],
      "type": "string",
      "description": "Which way it fits or does not."
    },
    "sessionId": {
      "type": "string",
      "description": "The session id returned by start_session. Everything the person tells you is stored against it, and it is the only thing linking one call to the next."
    }
  },
  "additionalProperties": false
}
rate_fit annotations
{
  "title": "Record how a shoe actually fits",
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
recommend_size — Recommend a size in a shoe they are considering
Advertised by the server during the last successful anonymous check.
Advertised read-only

Works out which size to buy in a shoe the person does not own yet, from the shoes they do own and any foot measurement. Needs at least one owned shoe or a measurement first. Returns the size and what it was based on.

recommend_size input schema
{
  "type": "object",
  "required": [
    "sessionId",
    "answers"
  ],
  "properties": {
    "answers": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The answers from find_shoe identifying the shoe they are considering. A size is not needed here: working it out is the point."
    },
    "sessionId": {
      "type": "string",
      "description": "The session id returned by start_session. Everything the person tells you is stored against it, and it is the only thing linking one call to the next."
    }
  },
  "additionalProperties": false
}
recommend_size annotations
{
  "title": "Recommend a size in a shoe they are considering",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-09: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
763 ms
95th percentile latency
763 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 763 ms · metadata changed · 8 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http getsize-mcp https://www.getsize.shoes/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add getsize-mcp --url https://www.getsize.shoes/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable getsize-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "getsize-mcp": {
      "url": "https://www.getsize.shoes/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "getsize-mcp": {
      "type": "streamableHttp",
      "url": "https://www.getsize.shoes/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start getsize-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "getsize-mcp": {
      "type": "http",
      "url": "https://www.getsize.shoes/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http getsize-mcp https://www.getsize.shoes/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://www.getsize.shoes/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "getsize-mcp": {
      "serverUrl": "https://www.getsize.shoes/mcp"
    }
  }
}

Let your agent find its tools

Find servers like GetSize MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 1,688

Do you run GetSize MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing