Licensing

The GroupDocs.Metadata MCP server runs in evaluation mode out of the box — no sign-up, no key. Your existing GroupDocs.Metadata license unlocks full functionality: point the installer’s licensePath — or the GROUPDOCS_LICENSE_PATH environment variable in a manual install — at your .lic file.

The MCP server itself is open source (MIT); the underlying GroupDocs.Metadata engine requires a license for production use.

There are three modes. The server takes the first one that is configured:

ModeConfigureResult
Metered (pay-per-use)GROUPDOCS_METERED_PUBLIC_KEY and GROUPDOCS_METERED_PRIVATE_KEYBilled for what you process; no evaluation limits
License filelicensePath / GROUPDOCS_LICENSE_PATHFully licensed; works offline
EvaluationnothingOnly the first 5 document properties are readable; XMP and EXIF are partly unavailable
Note
Metered wins. If both metered keys and a license file are configured, the server uses metered licensing and ignores the file — and says so in its startup log.

Evaluation mode limitations

Without a license:

  • Only the first five document properties can be read — every read_metadata result is silently truncated, which makes an unlicensed audit actively misleading.
  • XMP: only the first two schemes are readable. EXIF: GPS data and the image thumbnail are unavailable.
  • Writing and removal are limited in the same way, so a “strip everything” pass cannot be trusted without a license.

An empty license path is always safe — the server logs a notice and continues in evaluation mode; it never errors because a license is absent.

Applying a license

Installer config:

{ "licensePath": "D:/Storage/Licenses/GroupDocs.Metadata.lic" }

Manual (NuGet channel) — set the environment variable in your client’s server entry:

"env": { "GROUPDOCS_LICENSE_PATH": "/path/to/GroupDocs.Metadata.lic" }

Docker channel — mount the license folder read-only:

docker run --rm -i -v /path/to/documents:/data \
  -v /path/to/license-folder:/license:ro \
  -e GROUPDOCS_LICENSE_PATH=/license/GroupDocs.Metadata.lic \
  ghcr.io/groupdocs-metadata/metadata-net-mcp:latest

Your license file is read from local disk by the local server process — like your documents, it never leaves your machine.

Metered (pay-per-use) licensing

Metered licensing bills you for what you actually process, which suits AI agents: their usage is bursty and hard to size in advance. It is configured with two environment variables — there is nothing to mount and no file to ship:

"env": {
  "GROUPDOCS_METERED_PUBLIC_KEY":  "<your public key>",
  "GROUPDOCS_METERED_PRIVATE_KEY": "<your private key>"
}

One key pair covers every GroupDocs product and platform — the same pair you already use for the library works here, and the consumption it reports is account-wide rather than per server.

Warning
Both keys are required. With only one set, the server ignores the metered configuration and stays in evaluation mode — it reports this explicitly rather than failing silently. Check with get_license_status.
Warning
Metered mode needs outbound connectivity. Usage is reported to GroupDocs servers, so air-gapped or firewalled deployments must allow that egress — or use a license file instead. Only usage is reported; document content never leaves your machine.

Keeping the private key out of committed files

The private key is a secret, and client configurations are plain files on disk — a project-scoped .mcp.json is committed by convention. In order of preference:

  1. Set both variables in your OS environment and leave them out of the client config entirely. A stdio server inherits its client’s environment, so this works in every client.
  2. Reference them indirectly where the client supports it — Claude Code expands ${VAR}; VS Code uses ${env:VAR} and ${input:...}.
  3. A literal value in a user-scoped config (for example ~/.claude.json) is acceptable for a single developer.
  4. Never commit a literal key in a project-scoped .mcp.json.

With Docker, forward the two variables by name-e VAR with no value copies it from the launching process, so the key never appears in the file:

docker run --rm -i -v /path/to/documents:/data \
  -e GROUPDOCS_MCP_STORAGE_PATH=/data \
  -e GROUPDOCS_METERED_PUBLIC_KEY -e GROUPDOCS_METERED_PRIVATE_KEY \
  ghcr.io/groupdocs-metadata/metadata-net-mcp:latest
Note
On macOS, an app launched from Finder does not inherit variables exported in your shell profile. Use launchctl setenv, or start the client from a terminal.

Confirming which mode is active

Ask your agent “what is the license status of the metadata server?”. The get_license_status tool (server 26.9.0+) answers without processing a document:

{
  "mode": "metered",
  "licensed": true,
  "source": "metered-keys",
  "consumption": { "quantity": 1234.5678, "credit": 9642.0 },
  "server": { "name": "GroupDocs.Metadata.Mcp", "version": "26.9.0" },
  "engine": { "name": "GroupDocs.Metadata", "version": "26.6" }
}

If a key pair is rejected, the mode reverts to evaluation and the note field says why — for example “Metered keys were supplied but the engine rejected them (Authentication failed.)” — so a mistyped key surfaces here instead of as a truncated property list you might mistake for the whole truth.

Getting a license