AIMCPConnectorsAditya Uke

How to Build a Connector and Plugin for ChatGPT and Claude, Part 3: Secure, Test and Publish

Make your connector safe for real users, test it in ChatGPT and Claude, package it as a plugin with skills and prepare a listing that passes review.

Where we are

This is the final part of a three-part series:

  1. Plan before you code
  2. Build the MCP server, tools and widget
  3. Secure, test and publish on ChatGPT and Claude (this post)

If connectors and plugins are new to you, start with What Are Connectors and Plugins in ChatGPT and Claude?

In Part 2 we built an MCP server with tools and a widget. In this final part we make it ready for real users and put it live on ChatGPT and Claude.

Part A: Make it safe

A connector is a new public door into your product. Anyone can reach it through an AI chat, and scripts can call it directly. These basics cover most of the risk.

1. Validate everything

Treat every tool input as untrusted, even though it comes from an AI. Check types, lengths, formats and allowed values on the server. The schema in your tool definition is a hint for the model, not a security check.

2. Rate limit

  • Put rate limits on the MCP endpoint and on any public endpoints the widget calls.
  • Requests from AI clients often come from the provider’s servers, so many users can share one IP address. Combine per-IP limits with per-user or per-session limits.
  • If you are behind a CDN or proxy, read the real client IP only from headers your trusted proxy sets. Otherwise anyone can fake it.

3. Protect identities and tokens

  • Use OAuth for private data, or a confirmation step (for example an email link) before acting on an existing account.
  • Make tokens random, short-lived and single-use where possible, and store only their hashes.
  • Never log tokens, temporary file URLs, passwords or payment details.

4. Keep sensitive steps out of the chat

Card details, passwords and verification codes belong on your own website. Say so in your tool descriptions and instructions, and make sure the AI never asks for them.

5. Be careful with URLs you fetch

If a tool downloads a file from a URL, protect against SSRF (your server being tricked into calling internal addresses):

  • HTTPS only, and only from an allow-list of hosts
  • Check every redirect the same way
  • Block private and internal IP ranges
  • Enforce a size limit while downloading

6. Lock down the widget

  • A strict CSP that allows only the domains you need.
  • Escape every value you put into the HTML.
  • Accept postMessage messages only from the host window.
  • Open only https:// links.
  • Use CORS without credentials for any endpoints the widget calls; they should be authorised by a token, not cookies.

7. Make limits fair

For every limit, ask: “Could an attacker use this to lock out a real user?” For example, counting unconfirmed sign-up attempts against a user’s email would let anyone block that user. Count only actions the real user confirmed.

Part B: Test in the real clients

1. Deploy over HTTPS

Your MCP server must be reachable at a public HTTPS URL, such as https://mcp.example.com/mcp. For quick tests, a tunnel like ngrok or Cloudflare Tunnel can expose your local server.

2. Test in ChatGPT

  1. Turn on Developer mode in ChatGPT’s settings, under the apps and connectors section.
  2. Create a new app or connector with your MCP URL.
  3. Start a new chat, enable it and try real user sentences.

ChatGPT may cache your tool list and widget, so refresh or re-create the connector after changes.

3. Test in Claude

  1. Open Claude’s settings, go to Connectors and add a custom connector with your MCP URL.
  2. Enable it in a chat and run the same prompts.

4. What to check

  • The AI picks the right tool from a natural sentence.
  • The widget appears, fits the theme and works on mobile.
  • Every waiting step has a way forward.
  • The text-only path works when no widget is shown.
  • Errors are clear and friendly.

Part C: Package it as a plugin

A connector gives the AI abilities. A plugin adds know-how: skills, branding and setup in one installable package. A typical layout:

my-plugin/
├── plugin.json       # name, description, author, listing details
├── mcp.json          # where your MCP server lives
├── assets/logo.png
└── skills/
    ├── get-started/SKILL.md
    └── book-a-table/SKILL.md

mcp.json points to your server:

{
  "mcpServers": {
    "table-booking": {
      "type": "streamable-http",
      "url": "https://mcp.example.com/mcp"
    }
  }
}

What is a skill?

A skill is a short written guide, in a Markdown file, that teaches the AI how to do one whole task with your tools. If tool descriptions are the labels on the buttons, a skill is the training manual that explains which buttons to press, in what order and how to talk to the user along the way.

How it works:

  1. Each skill has a header with a name and a description.
  2. The AI reads only the headers at first. When a user’s request matches a skill’s description, the AI loads the full skill and follows it.
  3. The body holds the steps, the rules and the tone.

So the description decides when a skill is used. Write it with the words people actually say:

---
name: book-a-table
description: Find a restaurant and book a table. Use when the user wants to eat out,
  reserve a table or asks for restaurant suggestions for a date and time.
---

1. Make sure you know the city, date, time and party size. Ask only for what is missing.
2. Call `search_restaurants`. If a widget is shown, let the user pick there and keep your reply short.
3. Confirm the restaurant, time, name and email with the user, then call `book_table`.
4. Give the user the deposit payment link. When they say they paid, call `get_booking`.
5. When `get_booking` shows the booking is confirmed, share the confirmation exactly as returned.

Rules:
- Never say a table is booked unless `get_booking` shows it as confirmed.
- Never ask for card details in the chat; payment happens only on the payment page.
- Never invent restaurants, times or prices; only show what the tools return.

A plugin usually has a few small skills rather than one big one. For example, get-started introduces the app the first time someone uses it, and book-a-table handles the main task.

Tool descriptions vs. skills: where to put what

Put it in the tool description Put it in a skill
What this one tool does The full task, across several tools
When to call it, and what each input means The order of steps and what to ask the user
Rules that apply to this tool Tone, how much to say and what to avoid
The next tool to call How to handle the widget vs. a text-only chat

Two things to remember:

  • Tool descriptions must work on their own. Some clients use your connector without the plugin, so every tool should still make sense without a skill.
  • Don’t repeat everything everywhere. Keep important rules (like “never confirm a booking yourself”) in both places, and keep the rest where it belongs.

Part D: Publish

1. Prepare the listing

  • A clear name, a short description and a long description written for users
  • Logo (light and dark), brand colour and category
  • Example prompts, for example “Book a table for two tonight”
  • Links to your website, support page, privacy policy and terms
  • Screenshots of the widget in action

2. Verify your domain and submit

Both platforms have a review process for public listings. You may be asked to verify your domain by serving a token at a given URL, and to provide test instructions or a test account. Check each platform’s current developer docs, because the steps change often.

3. Pass the review

Reviewers behave like real users. They look for:

  • Honest tool annotations (read-only vs. destructive)
  • No sensitive data requested in the chat
  • No made-up results: the AI only reports what tools return
  • Clear errors and a support contact
  • A working flow from start to finish, including the text-only path

4. Watch and improve

After launch:

  • Track which tools fail and where users drop off.
  • Watch rate-limit rejections and unusual traffic.
  • Tweak descriptions and skills. Small wording changes often fix wrong tool choices.

Series recap

Part What you learned
1 Plan the conversation, tools, identity and widget screens, and see how tool descriptions and skills guide the AI
2 Build the MCP server, write tool descriptions and add an interactive widget
3 Secure it, test it in ChatGPT and Claude, write skills, package it as a plugin and publish

We followed these same steps to bring Bank Statements CSV / Card Statement CSV into ChatGPT and Claude, so users can convert their PDF statements to CSV just by typing in the chat.

Now it’s your turn: booking, ordering, documents, reports, support. If your users already ask an AI about it, a connector can let them get it done right there.

More on this topic:AIMCPConnectors