MCP Server

Vremly ships a Model Context Protocol server, so an AI assistant can work with your projects, customers, media and invoices directly instead of you copying data between it and the app.

It is a client of this same REST API. Everything on this page is governed by the API key you give it — the assistant has exactly the access that key has, and no more.

Quickstart

Pick your assistant. Most people want the hosted connector — one URL, no install. The CLI tabs are for coding agents already running on your machine.

Claude

1

Copy the Vremly connector URL

You’ll paste this into Claude in the next step.

https://mcp.vremly.com/mcp

2

Add it as a custom connector

In Claude, go to Settings → Connectors → Add custom connector, then paste the URL.

Open Claude Connectors

3

Sign in and choose access

Claude sends you to Vremly to sign in. Pick the organization and whether it may write, then approve. Try: “Which Vremly projects were delivered this week?”

ChatGPT

1

Copy the Vremly connector URL

The same URL every remote client uses.

https://mcp.vremly.com/mcp

2

Add it in ChatGPT

Settings → Connectors → Create, paste the URL and choose OAuth authentication. Custom connectors need a paid ChatGPT plan.

3

Sign in and choose access

You’ll be sent to Vremly to sign in, pick the organization and approve.

Claude Code

1

Add the server

One command. Claude Code runs the sign-in flow in your browser the first time it connects — there is no key to paste.

claude mcp add --transport http vremly https://mcp.vremly.com/mcp

2

Restart, then ask

Servers register at session start, so restart Claude Code first. Then try: “Which projects are still awaiting delivery?”

Cursor

1

Add to .cursor/mcp.json

Project-local, or ~/.cursor/mcp.json to make it global.

{
  "mcpServers": {
    "vremly": {
      "url": "https://mcp.vremly.com/mcp"
    }
  }
}

2

Enable it

Settings → MCP, confirm Vremly shows green, sign in when prompted, then ask in Composer.

Local install

Runs the server on your own machine over stdio, authenticating with an API key instead of signing in. Use it when you would rather hold the credential yourself, or for a host that cannot reach a remote server.

1

Create an API key

In the Vremly app, go to Settings → Developers → API Keys. Grant READ unless the assistant genuinely needs to write.

Open API Keys

2

Point your host at the command

Nothing to clone or build — npx fetches and compiles the server on first run. Node 18 or newer.

claude mcp add vremly \
  --env VREMLY_API_KEY=your-api-key \
  -- npx -y github:RelayDigital/vremly-mcp

Both routes reach the same API and expose the same three tools. The hosted connector signs you in and issues its own credential; the local install uses an API key you create yourself.

What approving actually grants

Approving a connector creates an ordinary API key in your organization, named after the assistant. That is the entire grant — there is no separate “connector permission” with rules of its own.

Which means everything you already know about keys applies unchanged:

• it belongs to one organization, and the server derives that organization from the key, so an assistant cannot reach another one
• its scopes are enforced on our servers, on every request
• it appears in Settings → Developers → API Keys beside your other keys
• revoking it there disconnects the assistant immediately

Read-only is preselected on the approval screen. Write access is a deliberate choice, and worth declining unless you need it — see Permissions for why that matters more with an assistant than with your own code.

Local install configuration

Environment variables for the local install only. The hosted connector needs none of these — it is configured by the approval screen.

Variable	Default	Purpose
VREMLY_API_KEY	(required)	Your organization API key.
VREMLY_API_URL	https://api.vremly.com	API base URL.
VREMLY_MCP_READ_ONLY	unset	1 refuses anything but GET/HEAD/OPTIONS.
VREMLY_MCP_TIMEOUT_MS	30000	Per-request timeout.
VREMLY_OPENAPI_PATH	bundled	Point at a different OpenAPI document.

What it exposes

Three tools, not one per endpoint:

Tool	Purpose
vremly_search_endpoints	Find endpoints by keyword.
vremly_describe_endpoint	The endpoint's parameters, required body fields and responses.
vremly_request	Call it, and return the status and body.

The API has hundreds of operations. A tool per operation would cost more context to list than most tasks cost to do, and many assistants cap how many tools they will accept. Search → describe → request reaches all of them at a fixed cost, and because the search reads the OpenAPI document directly there is no generated tool list to fall out of date.

Describing before calling is not optional

The API validates with whitelist: true: a body field it does not recognise is silently dropped, not rejected. A request built from a guessed field name returns 201 having ignored the field. vremly_describe_endpoint is what stops an assistant guessing.

Permissions

What the assistant can do is decided by the key, checked on our servers, on every request.

Scope	Grants
READ	GET, HEAD, OPTIONS
WRITE	Everything READ allows, plus POST, PUT, PATCH, DELETE
ADMIN	Everything
BULK_IMPORT	The bulk import endpoints only
WEBHOOKS	Managing webhook subscriptions

A key belongs to one organization and the server derives the organization from it, so the assistant can never reach another organization's data.

Give it a READ key unless it needs to write

That is the guarantee that holds even if the assistant is prompt-injected by something it reads — a listing description, an email, a web page. A read-only key cannot be talked into deleting a project, because the refusal happens on our servers and not in the assistant's judgement.

VREMLY_MCP_READ_ONLY=1 is a convenience, not a security boundary: anything able to set that variable could also unset it. The key's scopes are the boundary.

An ADMIN key can mint more keys

Revoking a leaked ADMIN key does not necessarily contain it, because it may already have issued others. Grant it only when something genuinely needs organization-level settings.

Requests are rate limited per key — 3/second, 20/10 seconds, 100/minute. See Rate Limits.

Verifying a local install

The hosted connector needs no verification step — if Claude shows it as connected, it is. For a local install, the server writes a status block to stderr on start — never stdout, which carries the MCP protocol itself. Run it directly to see it:

VREMLY_API_KEY=your-api-key npx -y github:RelayDigital/vremly-mcp

  ██╗   ██╗██████╗ ███████╗███╗   ███╗██╗  ██╗   ██╗
  ██║   ██║██╔══██╗██╔════╝████╗ ████║██║  ╚██╗ ██╔╝
  ██║   ██║██████╔╝█████╗  ██╔████╔██║██║   ╚████╔╝
  ╚██╗ ██╔╝██╔══██╗██╔══╝  ██║╚██╔╝██║██║    ╚██╔╝
   ╚████╔╝ ██║  ██║███████╗██║ ╚═╝ ██║███████╗██║
    ╚═══╝  ╚═╝  ╚═╝╚══════╝╚═╝     ╚═╝╚══════╝╚═╝

  Model Context Protocol server  v0.1.0

  ✔ endpoints   268 operations
  ✔ api         https://api.vremly.com
  ✔ api key     VREMLY_API_KEY detected
  ✔ mode        read + write, limited by key scopes
  ✔ transport   stdio

  Ready. Ask your assistant to search the Vremly API.

It appears to hang after printing. That is correct — a stdio server waits on stdin for the host to speak to it. Press Ctrl+C to exit.

The key line is the one worth reading. The server reports ready whether or not a key was supplied, because dying during the handshake surfaces in most hosts as an unexplained "server failed to start" with the real reason lost. If that line shows a warning, the server is fine and the environment is not — the host is not passing VREMLY_API_KEY through.

Keeping a local install current

The OpenAPI document ships inside the server, so a fresh npx install always carries the specification as of the last release. npx -y re-resolves the repository, so removing the cached copy picks up the newest server:

rm -rf ~/.npm/_npx && # then restart your assistant

Pin a tag instead if you would rather decide when that happens.

Other agent-readable resources

• /llms.txt — a machine-readable index of this documentation, following the llms.txt convention.
• The OpenAPI document — the complete contract. It is the authority whenever a guide disagrees with it.