Connect Galley to your assistant

You do not need to write any code to use Galley. If you have Claude or ChatGPT, you can hand it Galley’s address once and from then on ask it for a real document — an invoice, an estimate, a set of minutes — and get back a PDF you can send, print or sign, built from the same template every time.

The four-tab version

Pick your assistant. Every step below is quoted from the product's own documentation and was checked on 16 September 2026.

Galley's address https://mcp.galleyrender.com/mcp

Streamable HTTP, with no sign-in, key or OAuth. Your first documents are free. When you want more, ask your assistant to make you an account. You'll get an email that shows who asked and a short code, and you confirm it there. Already have a key? The last step in every tab below is where it goes: a header for Claude Code and Cursor, and, for Claude.ai and ChatGPT, a personal address plus the link_account tool.

Claude.ai

The web app at claude.ai, and Claude Desktop. Free, Pro, Max, Team and Enterprise. On Team and Enterprise an owner adds it once for the organization, then everyone connects to it.

Open claude.ai → Customize → Connectors.
Click +, then Add custom connector.
Paste your personal address into the URL field. It's made here, in your browser, and nobody else has it:
https://mcp.galleyrender.com/mcp/c/…
Leave Advanced settings alone. That's where an OAuth client id and secret would go, and Galley doesn't need either.
Click Add. Galley's tools are now in the tools menu of any new chat.
Try it: ask for one of the documents below and watch it approve the tool call.
Use your key. Claude.ai's connector dialog can't send an HTTP header, so the key goes in through a tool instead. Ask Claude: run link_account with my Galley key. If you'd rather not paste a key into a chat, ask it to run create_account with my email address. An address that already has an account gets a one-time code by email instead of a second account, and link_account takes that code. Check it worked with run whoami. This works because of your personal address: Claude calls Galley from Anthropic's servers, so on the shared address every Claude user looks the same, and that one can't be linked to anybody's account.
what to say text
```
Run link_account with this key: glr_sk_…

or, with no key to hand:

Run create_account with my email, then link_account with
the code that arrives.
```

Customize → Connectors, with the custom connector dialog open and the URL field highlighted.

On Team or Enterprise the first step is an owner's job: Organization settings → Connectors → Add → Custom → Web. Everyone else then finds it under Customize → Connectors and clicks Connect.

Keep your personal address to yourself. Once it's linked, whoever has it is using your account, the same as with a key. Don't paste it into a shared document. If somebody else might have seen it, ask for unlink_account and add Galley again with a new one. On a Team or Enterprise plan, an address an owner adds for the organization is shared by everyone in it.

ChatGPT

The ChatGPT web app. Plus, Pro, Business, Enterprise and Education, on the web. ChatGPT's free plan can't add a custom connector. On a free account, use Claude, which can.

In ChatGPT, open Settings → Security and login and turn on Developer mode.
Go to chatgpt.com/plugins.
Click the + button and create a developer-mode app for a remote MCP server.
Paste your personal address as the server URL. It's made here, in your browser, and nobody else has it:
https://mcp.galleyrender.com/mcp/c/…
Leave authentication empty, because Galley doesn't need any.
Save. Your new app appears under Drafts. It's yours to use, and nothing is submitted to OpenAI or reviewed by anyone.
In a chat, enable it and ask for a document. ChatGPT asks you to confirm the first time it makes a file. That prompt is normal for any action that writes something.
Use your key. Leave the authentication fields empty (Galley doesn't use OAuth) and hand the key over with a tool instead: run link_account with my Galley key. No key to hand? Run create_account with my email address. If that address already has an account, we email it a one-time code, and link_account takes the code. Run whoami confirms which account you're on. It works because of your personal address: ChatGPT calls Galley from OpenAI's servers, so on the shared address every ChatGPT user looks the same, and that one can't be linked to anybody's account.
what to say text
```
Run link_account with this key: glr_sk_…

or, with no key to hand:

Run create_account with my email, then link_account with
the code that arrives.
```

Settings → Security and login with Developer mode on, and the new-app dialog with the server URL field highlighted.

Older ChatGPT builds and older help articles call this a connector instead of an app. It's the same thing.

Claude Code

The terminal tool. For people who do write code. Any plan that runs Claude Code.

Add the server. --scope user makes it available in every project. Leave it off and it's only added to the current one.
terminal bash
```
claude mcp add --transport http --scope user \
  galley https://mcp.galleyrender.com/mcp
```
Check it: claude mcp list should show galley connected.
Ask for a render. The first call with no key mints a trial and hands the token back in the response.
Use your key. Add it as a header and every call is on your account rather than on the keyless trial. Re-run the add command with --header; it replaces the entry. Then ask Claude to run whoami — it should say authenticated_via: "header".
terminal bash
```
claude mcp add --transport http galley https://mcp.galleyrender.com/mcp \
  --header "Authorization: Bearer $GALLEY_API_KEY"
```

One command in a terminal.

Cursor

The editor. Any plan.

Put this in ~/.cursor/mcp.json for every project, or .cursor/mcp.json in a repo for just that one.

~/.cursor/mcp.json json

{
  "mcpServers": {
    "galley": {
      "url": "https://mcp.galleyrender.com/mcp"
    }
  }
}

Open the Customize panel in the sidebar and make sure galley is toggled on. A server that's toggled off doesn't load or appear in chat.
Ask for a render. The first call with no key mints a trial and hands the token back in the response.
Use your key. Add a headers entry beside the url and every call is on your account rather than on the keyless trial. Reload the server from the Customize panel, then ask for whoami — it should say authenticated_via: "header".
~/.cursor/mcp.json json
```
{
  "mcpServers": {
    "galley": {
      "url": "https://mcp.galleyrender.com/mcp",
      "headers": { "Authorization": "Bearer glr_sk_…" }
    }
  }
}
```

The mcp.json entry, with the URL highlighted.

Then tell it what to do with the pack

Paste this once — into a Claude Project's instructions, a ChatGPT project, or just the top of a chat. It tells your assistant which document to reach for and, above all, to make the real file rather than typing one out.

This one is written for a contractor, as a worked example. Swap the template names and the questions for whatever you make every month.

You help me run the paperwork for my remodeling business with Galley
Render, which is connected as a tool. Everything you produce comes out of
Galley as a real PDF I can send, print or sign.

Always render the real document with Galley. Never write the document out
in the chat, never improvise a layout, and never make up a template name.
If you are not sure which one fits, call list_templates and choose from
what comes back.

Which template to use:
- an estimate, a bid, a quote for a job -> quote
- a change order, extra work, a scope change -> change-order
- an invoice, a bill, a progress billing -> invoice
- a certificate of completion or a workmanship warranty -> certificate
  (kind: "completion" for finished work, kind: "warranty" for a warranty)
- a receipt, proof they paid, a deposit receipt -> receipt

Before you render, make sure you have these. Ask for all the missing ones
in one message, then render. Never guess a number, a date, an address or a
licence number.
- Every document: my company name and licence number, the customer's name,
  the job address.
- quote: quote number, date, line items with labor and materials, and what
  is excluded. Ask what is not included if I did not say.
- change-order: change order number, the original contract sum, the total
  of earlier change orders, what is being added or removed, and the
  schedule impact in days.
- invoice: invoice number, date, line items, payment terms, and any
  deposit to apply.
- certificate: whose name goes on it, the job address, the completion
  date, who signs.
- receipt: amount, date, how they paid, what it was applied to, the
  balance left.

Before you use a template for the first time, call get_template and read
its schema - it is free. If a render fails validation, read the field path
in the error, fix that one field and try again. Do not give up and type
the document into the chat.

Keep my numbering going: ask me the last quote, change order and invoice
number if you do not know them, then increment. Carry the same company
details, licence number and terms from one document to the next so
everything I send looks like it came from the same office.

When a render succeeds, give me the link, tell me which template made it,
and ask if I want the next document in the sequence.

Do not tell me what any of these documents means legally, and do not
invent figures. If a number is missing, ask me for it.

What your assistant can do once it is connected

16 tools, but three of them carry almost every conversation:

list_templates — what documents it can make. Every account starts with the full starter library, so this is never empty.
get_template — the fields a template expects. Free, and worth doing before the first use of anything unfamiliar.
render — the document itself, as a signed URL to a PDF, PNG or JPG.

The first render with no key mints a free trial and hands back a token. When you want more, ask your assistant to make you an account. create_account takes an email and mails you a link, and your assistant tells you a four-letter request code. The link opens a page that shows who asked, when, and the code. If the code is the one your assistant gave you, press Yes, that was me, and your assistant gets the key. Your trial, and everything you’ve already made, carries over. If the code isn’t yours, somebody else asked for your address: press No, this wasn’t me and nothing happens.

Use your key

If you already have a Galley key, the trial is not what you want. 10 PDF pages or 10 images is a sample; your account has your plan, your templates and your renders on it. There are two ways to connect them, and which one you use depends on whether your assistant can send an HTTP header.

Clients that can send a header — Claude Code, Cursor

This is the better path when it is available. The key rides on the connection, so every call is on your account, and nothing about it depends on your IP address.

claude mcp add --transport http galley https://mcp.galleyrender.com/mcp \
  --header "Authorization: Bearer $GALLEY_API_KEY"

{
  "mcpServers": {
    "galley": {
      "url": "https://mcp.galleyrender.com/mcp",
      "headers": { "Authorization": "Bearer glr_sk_…" }
    }
  }
}

X-Galley-Key: glr_sk_… works too, for a client whose config makes Authorization awkward.

Clients that cannot — Claude.ai, ChatGPT

A custom connector dialog has nowhere to put a header. Use the link_account tool instead; it ties this client to your account once, and every call afterwards is on it.

That needs the connector to be yours, so add it with your personal address, the one the Claude.ai and ChatGPT tabs above make for you: Galley’s address plus /c/ and a random id. Claude.ai and ChatGPT call Galley from their own servers, so on the shared address every one of their users looks the same. That’s fine for the free trial, but it can’t be linked to an account, and link_account will say so rather than let one person’s account open for everybody. If you added the shared address, remove the connector and add it again with a personal one.

You: Run link_account with this key: glr_sk_…

Do not want to paste a key into a chat? Ask for an account with the address you already signed up with:

You: Run create_account with my email, matt@example.com

Because that address already has an account, Galley does not make a second one. It mails a one-time code — GLR-4F7K-9QX2, good for ten minutes and one use — and you read it back:

You: Run link_account with the code GLR-4F7K-9QX2

Either way, whoami confirms it: ask your assistant to run it and you should see your account id, your plan, and authenticated_via: "binding".

Two things worth knowing

Once it’s linked, your personal address works like a key. Whoever has it is using your account. Don’t paste it into a shared document, and if you think somebody else has seen it, ask for unlink_account and add the connector again with a new address. On a Team or Enterprise plan, a connector an owner adds for the organization is shared by everyone in it.

A key that does not work is refused, not ignored. If your assistant sends a key Galley cannot match, it gets an error naming the header the key came in on — it does not quietly fall back to the free trial. That is deliberate: the alternative is the trial’s pages spent on a throwaway account and a quota message about a limit you never signed up for.

Prove the address works before you paste it

If a connector dialog ever refuses the URL, check the server rather than guessing. This asks it who it is, and needs nothing but a terminal:

curl -sS https://mcp.galleyrender.com/mcp \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-06-18","capabilities":{},
                 "clientInfo":{"name":"you","version":"1"}}}'

A healthy server answers with "name":"galley-render" and the protocol version it agreed to.

If something goes wrong

The dialog asks for a client id and secret. It should not — those fields are optional and Galley needs neither. Leave them empty. If the form insists, you are in an OAuth-only dialog; back out and use the plain “custom connector” path.

ChatGPT does not show developer mode. It is not available on the free plan, and the documented path is the web app rather than the phone apps. On a free account, Claude’s free plan does allow custom connectors.

You are on a Team or Enterprise plan and there is no “add” button. Adding a connector for the first time is an owner’s action in organisation settings. Once an owner has added it, it shows up for you under Customize → Connectors with a Connect button.

Your assistant writes the document into the chat instead of making a file. It has the connector but not the instruction. Paste the skill prompt above; the sentence that does the work is “Always render the real document with Galley.”

“Trial limit reached: 10 PDF pages or images” — but you have an account. The key never reached the server, so the renders came out of a keyless trial rather than your account. Ask your assistant to run whoami: if it says authenticated_via: "trial", follow Use your key above. Nothing is lost — the trial is a separate account, and yours still has whatever it had.

link_account says this client “has no identity of its own”. The connector was added with the shared address. Remove it and add it again with the personal address from the tab above, then run link_account again. The code you were sent still works for ten minutes, because nothing was spent finding this out.

The email shows a request code you don’t recognise. Somebody else asked for an account with your address. Press No, this wasn’t me. They get nothing, and your own request, with your own code, still works.

Your assistant offers to make you a second account. Do not let it. Give it the address you already signed up with: create_account with an address that already has an account returns existing_account: true and mails a link code instead of making another one. A second account means a second free tier and none of your templates.

What we send, and what we keep

Galley sees the data you ask it to put in the document, because that is what it renders. It does not see the rest of your conversation. Renders are cached by content, so asking for the same document twice returns the same file and is not billed twice. The security page has the rest.

Also worth reading

The MCP server — the transport, the tools, and the keyless trial, for people who do write code.
Claude Code and Cursor — the longer versions of the last two tabs.
Skill file and llms.txt — what an agent reads before it connects.