FixedQR
Server Details
Generate static QR codes that never expire, as PNG images or SVG. No account or API key needed.
- Status
- Healthy
- Uptime
- 100.0% over 19 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 3 tools
Each tool targets a distinct outcome: static QR generation versus dynamic (redirect) code creation versus updating an existing dynamic code. Descriptions clearly contrast the static 'never expires' behavior against the 'fixedqr.com/r/<id>' redirect model, so an agent can select correctly.
All three follow a verb_noun pattern, but the verbs diverge for essentially similar create actions ('create_dynamic_code' vs 'generate_qr') and the noun suffix is inconsistent ('_code' vs '_qr'). Readable but not fully uniform.
Three tools is on the thin side for a QR management service; the surface covers creation/update but leaves obvious management operations unrepresented. Borderline rather than clearly wrong.
Creation of both static and dynamic codes plus update are covered, but there is no delete/deactivate, no list, and no get/read for owned dynamic codes. Agents have dead ends when managing existing codes.
Available Tools
3 toolscreate_dynamic_codeAInspect
Create an editable (dynamic) QR code that redirects via fixedqr.com/r/. Requires a FixedQR API key (Authorization: Bearer fq_...) and an active plan. The redirect keeps working even if the plan lapses.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | ||
| target | Yes | Destination URL (https) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so the description carries the full burden, and it does substantial work: it discloses the auth requirement (Bearer fq_...), the plan requirement, and an important lifecycle behavior ('redirect keeps working even if the plan lapses'). What it omits is what happens on failure (e.g., missing key, expired plan) and whether creation is reversible/deletable. Still, for an unannotated mutation tool this is above-average behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, each earning its place: what it does, what it requires, and a non-obvious behavioral guarantee. Front-loaded with the core action and free of filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter creation tool with no output schema, the description covers purpose, auth, plan requirements, and redirect persistence. The main gap is the undocumented 'label' parameter and no mention of what is returned or what happens on failure, but the core calling context is complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%: 'target' is documented as an HTTPS destination URL, but 'label' has no description anywhere. The tool description mentions neither parameter by name nor adds semantics. With half the parameters undocumented, the description does not compensate, so this lands at the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Create an editable (dynamic) QR code') and explains the redirect mechanism via the fixedqr.com/r/<id> URL pattern. This clearly distinguishes it from generate_qr (presumably static) and update_dynamic_code, which implies this is the creation counterpart to a separate update tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states prerequisites (API key, active plan), which implicitly tells the agent when the tool is usable. However, it never states when to prefer this over generate_qr or update_dynamic_code, nor does it give exclusions. The usage context is implied by the prerequisites rather than made explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_qrBInspect
Generate a static QR code (never expires; content encoded directly, no redirect). Returns an image (PNG) or SVG text.
| Name | Required | Description | Default |
|---|---|---|---|
| bg | No | #ffffff | |
| ec | No | M | |
| fg | No | #000000 | |
| org | No | ||
| url | No | ||
| data | No | URL or text (for url/text types) | |
| size | No | ||
| ssid | No | ||
| type | No | url | |
| No | |||
| phone | No | ||
| format | No | png | |
| hidden | No | ||
| password | No | ||
| last_name | No | ||
| encryption | No | ||
| first_name | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden and does disclose useful traits: static/non-expiring encoding, no redirect, and that output is a PNG image or SVG text. However, it omits auth/permission needs and, critically, which parameters are required per QR type despite 17 optional parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences with the core action first and the differentiating static/return-format details immediately after. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 17-parameter tool with no annotations and no output schema, this description is far too thin. An agent cannot tell which fields are required for each type, how the styling parameters interact, or what the returned image/SVG looks like, so it would likely need to guess or retry.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 6% across 17 parameters, so the description should compensate and does not. It only indirectly touches 'format' (PNG/SVG) and 'data'; the type-specific groups (ssid/password/encryption for wifi, first_name/last_name/email/phone/org for vcard) and styling params (bg, fg, ec, size, hidden) are undocumented in both places.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Generate a static QR code') and adds a meaningful domain distinction between static and dynamic codes (never expires, no redirect, content encoded directly). Clear on its own, though there are no sibling tools to differentiate against.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool or how to choose between the four supported types (url, text, wifi, vcard). The agent is left to infer that 'type' selects the payload mode and which fields each mode requires.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
update_dynamic_codeBInspect
Change the destination or label of an editable QR code you own. Requires a FixedQR API key and an active plan.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ||
| label | No | ||
| target | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It usefully discloses the auth prerequisites (FixedQR API key, active plan), but says nothing about failure modes, whether edits break existing scans, or whether changes are reversible — meaningful gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, front-loaded with the action and followed by prerequisites. No filler, though it could have used a few of those words to clarify the id parameter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations, no output schema, and 0% parameter coverage, the description is thin: it omits what 'id' identifies, whether label/target are both optional, and what the result of an update looks like. Auth context is present but insufficient overall.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% across 3 parameters, so the description must compensate and only partly does. It implies 'label' and 'target' semantics via 'label'/'destination', but the mismatch ('destination' vs schema's 'target') risks confusion, and the required 'id' parameter is never explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Change the destination or label of an editable QR code you own.' This distinguishes it from create_dynamic_code and generate_qr by scope (modify vs. create/generate), though it doesn't name the siblings explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'an editable QR code you own' plus the plan/API key requirement implies when the tool is applicable, but there is no explicit when-not guidance or reference to an alternative (e.g., use create_dynamic_code for new codes). Usage must be inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
- Added
create_dynamic_code - Added
update_dynamic_code
1 tool update
- First observed
generate_qr
Related MCP Connectors
Free static QR codes (PNG or SVG) that never expire, for URLs, WiFi, vCards and text. No account.
Generate static QR codes (URL, WiFi, vCard, pixel art) and decode QR images. Codes never expire.
Static QR codes and 1-D barcodes (Code 128, EAN-13, UPC-A, EAN-8) as SVG, PNG or data URL.
Generate styled QR codes as SVG or PNG: colors, module shapes, ready-made presets and brand logos.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables generating QR codes from URLs or text without an API key, and creating trackable short links whose printed QR codes can be re-pointed after printing.48 npmMIT
- AlicenseNot gradedqualityAmaintenanceGenerate QR codes and create, edit and track dynamic (editable) QR codes with scan analytics, folders, style themes and branded subdomain management. Free REST API with an OpenAPI spec alongside; every tool takes a free API key.12AGPL 3.0
- AlicenseAqualityDmaintenanceGenerates QR code PNG images from text or URLs with customizable options like size, color, and error correction level.1MIT
- AlicenseAqualityBmaintenanceEnables AI agents to generate static QR codes as PNG images or SVG markup for any URL or text, entirely locally with no account or API key, and to obtain prefillable links to a free online QR designer. It also provides instructions for creating dynamic, tracked short-link codes.338 npmMIT
Glama MCP Gateway
Add one secure layer between your agents and this server.