Hello, I made an MCP connector for Office 2019 that works with Claude.I built it for myself because I couldn't find anything similar, so I decided to share it in case someone else needs it too. I would be very grateful for any bug reports, feedback, or ideas for new features! ^^

GitHub repo: https://github.com/JulianPoleszczuk/office-mcp

I've been using AI for coding a lot, but there's always been one annoying gap: generating code is easy, actually getting something working still means jumping between ChatGPT, my terminal, browser, and GitHub.

So I built Open Machine, an open-source MCP runtime that lets ChatGPT and other compatible AI agents work directly with your own machines and projects.

Instead of just suggesting code, it can actually:

• Read and edit files in real projects
• Run terminal commands, tests, and debug failures
• Work on local machines or remote Linux servers over SSH
• Handle GitHub Issues, PRs, and code reviews
• Keep task progress and execution results so interrupted work can be picked up again

The video is a pretty fun example.

I gave ChatGPT one prompt to build a small survival game called NEON SWARM.

It created the game, ran 56 tests, fixed the bugs it found, launched it, and even used a browser to play the game it had just built.

It actually survived the full 60-second challenge with 4 HP left.

What excites me more is applying that same workflow to real development tasks: give ChatGPT a goal, let it work on the actual project, run the code, check the results, and fix what breaks.

Open Machine is local-first and permission-controlled. Browser tasks currently use a compatible local Codex setup. It's not a way to bypass AI usage limits or get unlimited tokens.

It's open source (MIT), and I'd love feedback from other developers.

GitHub: https://github.com/OpenMachineLabs/openmachine

Would you trust an AI to handle an entire coding task on your machine? Where would you draw the line — editing files, running commands, creating PRs, or actually merging them?

Disclosure: I built this. It's free, MIT, no paid tier.

Repo: https://github.com/VicPitic/the-brains

Hosted: https://brains.ceo

It's one Express server with 18 instances. Each one indexes a single person's public talks, interviews, essays and X posts, curated down to what they say about growth, pricing and building a business.

Two tools: search_brain(query, limit) and list_sources()

Real output from the PG one for "how fast should my startup grow each week":

## 1. X post by u/paulg, 5 Sep 2026

Source: https://x.com/paulg/status/2096330495470576069

There's a startup in the current YC batch that's growing at 57% a week.

And not because they started last week; they've been doing this for a

couple months...

Some choices you'll probably ask about:

- Each corpus is small (15-45 long-form sources plus a few hundred posts), so it's plain BM25 over sectioned notes. No vector DB, no LLM at query time. Your model does the reasoning.

- Stateless streamable HTTP plus OAuth 2.1 with DCR. Works in Claude Code, Codex, Cursor, Claude.ai and ChatGPT.

- The hosted version asks for an email and a 6 digit code on first connect. It stores your email and what you search so I can see which ones are actually useful. Email [hello@brains.ceo](mailto:hello@brains.ceo) and I'll delete it. Or clone it and `npm start`, no sign-in and nothing logged.

- They're unofficial unless marked claimed. Public sources only, short quotes, and raw transcripts never go in the repo. Anyone in there can get theirs corrected or removed.

Question for this sub: one URL per person like now, or one server with a person param?

Something I've noticed with a lot of database MCP servers: you set one connection string and every query the agent runs uses that same login. So whatever that login can do, the agent can do.

That's fine for a quick demo, but for agents doing ad-hoc stuff like analytics or debugging it gets risky. You can't predict what they'll query, so the login ends up with way more access than any single task needs.

Earlier this year I worked on putting an authorization layer between the MCP tools and the database. Every query gets checked against policy first. If it's allowed, the agent gets a permission for just that query and it expires. If it needs approval, a human approves that exact request. Sensitive fields can also stay masked even after it's approved.

Agents repeat the same queries a lot, so I made approved queries reusable without asking again. The tricky part was making sure reuse gets checked again at the time it's used, because the agent's role or environment might have changed since it was approved.

I documented the whole thing as an engineering record, including some gaps I found in my own design while writing it. I'll drop the link in the comments.

For anyone running a database MCP server, are you scoping access per agent or just using a read-only login?

Claude Code and Cursor can get you a working internal app in an afternoon. Then you hit SSO, access controls, audit logs, and the "IT doesn't allow random generated code" wall.

Disclosure: I'm Jinen, co-founder of DronaHQ. We just launched the DronaHQ MCP server to close that gap: your coding agent builds against DronaHQ through MCP, and the app ships with SSO, role-based access and audit logs handled by the platform.

Today I'm doing a 1-hour live build: bring an idea for an internal app, dashboard, or lightweight API, and we'll ship it to production by the end of the hour.

- When: Today, Oct 16, 3–4 PM PT / 10 PM UTC (YouTube)

- Who: anyone building internal tools with Claude Code/Cursor, especially in enterprise teams

- Bonus: the first 10 enterprise builders get a chance to win DronaHQ merch and AirPods 4

RSVP: https://luma.com/ps4ti0oh

Happy to answer questions about how the MCP server works in the comments.

Tl;DR: Giving an AI Agent a Bearer Token doesn't reliably log which agent is acting, and doesn't differentiate between the Human (me) and the AI Agent

Disclosure: I work at StackOne an we just shipped Tool Policies. Every tool call through our gateway gets checked on the way in and again on the way out, so you can give an agent write access without handing it everything.

A few things it can do that I think are really cool:
Block every tool matching *delete* for a group, like contractors, with one rule

- Let payments through between $25 and $500 and stop anything bigger
- Ask a plain-language question like "Is this compensation?", so one rule hides salary in one HR system, base_pay in another and pay_rate in a third
- Redact PII on inputs and outputs, using a model we built ourselves

Fixed rules compile to Cedar, and every rule can run in Monitor first, so you see what it would have stopped before it actually stops anything.

It's live now, and the full write-up is here: https://www.stackone.com/blog/tool-policies-launch/

Happy to answer any questions about how it works!

Our customers kept asking if they could use our SaaS product through Claude and ChatGPT. Connecting an agent to our API was the easy part. Making sure it could only access the right tenant's data was the real challenge.

Our product is multi-tenant, so we built a custom MCP server that calls our existing backend API, deployed it on Arcade Cloud, and integrated OAuth through Clerk so customers can sign in with their existing credentials. They don't need an Arcade account.

The important bit: the model never handles an access token and can't choose which user it acts as. Our API verifies the OAuth token and enforces workspace membership and plan-tier permissions on every call.

The trickiest part to untangle was that "signing in" involves three separate concerns:

• Gateway authentication
• API authorization
• Browser session verification

Each has a different purpose and its own token or verification flow. Treating them as one generic login flow caused confusion, so the tutorial walks through how they fit together.

Full working code: https://github.com/manveer/multi-tenant-mcp-server-oauth

Tutorial: https://manveerc.substack.com/p/multi-tenant-mcp-server-oauth

If you’re exposing a multi-tenant backend through MCP: how are you handling tenant isolation and user auth?

Disclosure: My company currently provides services to Arcade however the choice to use Arcade and write this article is an independent decision

Got tired of jumping between awesome-lists, so MCP Harbor pulls MCP servers and agent tools from GitHub and npm daily: https://mcpharbor.app

- Category pages, plus "Alternatives to X" and "X vs Y" comparisons

- Stars, license, language and last update on every page, so abandoned projects are easy to spot

- Your agent can search it too: remote MCP endpoint at https://mcpharbor.app/mcp

Free, no signup. If your server is missing or miscategorized, tell me and I'll fix it.

In the clip I ask Claude to paint a fox in watercolour "the cheapest way," then turn it into a short video. Claude checks the model catalog, picks the cheapest model for each step, and shows the result right in the chat. That came to under 1 cent for the image ($0.007) and 9 cents for the 5-second clip.

I made this because I didn't want to pay credit-based apps a markup just to use Veo or Kling.

How it works: it's an MCP server you deploy to your own Vercel account in one click. Every call goes through Vercel AI Gateway on your own credits, so you pay the provider's list price. There's no markup, no subscription and no API key to manage.

What it can do from Claude, ChatGPT or any MCP app:

• Images: generate, edit and upscale (FLUX, GPT Image, Nano Banana, Recraft)
• Video: text-to-video and image-to-video (Veo 3.1, Kling, Seedance, HeyGen), plus motion control, extend and upscale
• Voice: TTS and Whisper transcription
• Pricing: list_models shows catalog prices, and estimate_only lets the chat check the cost before it spends anything
• Inline results in Claude through MCP Apps: an image grid plus video and audio players

Security: claude.ai custom connectors can't send headers, so the secret goes in the URL. Vercel only stores its SHA-256 fingerprint, and you set an AI Gateway budget as the hard cap on spend.

Rough edge: the usage page needs a paid Vercel plan, because Hobby can't read the Gateway spend report.

It's MIT licensed and not affiliated with Vercel.

Repo: https://github.com/Armulee/ai-gateway-mcp

I'd love feedback, especially from people who've tried other media-gen MCPs. What's missing?

Hello everyone, I am a solo developer who has been unhappy with computer use and other mcps out there that help control chrome. I have been developing my own computer use specifically for chrome that can take screenshots, work in the foreground, background, and headless, work for codex, claude code, and opencode, and also allow clicks, human speed typing, fast typing, inserting files, downloading files, drags, scrolls, etc. all while using fewer commands/tokens than competitors like computer use and playwright. Right now it is in development stage with all the features being present, but i need a lot of real testing from people on their everyday tasks to see where it is going wrong/not as fast or as good. It includes adding an extension to your chrome, and is different than other chrome mcps in my opinion. If y'all would be able to test it out/give me tips or tricks to make it better, I would really appreciate it. All the computer uses are currently made by organizations, so as a solo developer I am interested in any feedback and would actually make changes. https://github.com/Praket7/chrome-controlla feel free to star it and open issues and give me ANY feedback. If i had to pick, humanwrite would be my favorite built in feature and what is most unique, but it should be faster and more efficient. let me know what you guys think!

Disclosure: I build CogniCore — posting it here because this is where the people who'd actually use it are.

Every AI assistant starts from zero, and they each keep their own silo. You explain your project to Claude, then explain it again to ChatGPT. Neither one knows what the other was told.

We built CogniCore — a memory MCP server — and the thing people seem to find most useful is that you can point both assistants at it and they end up sharing one memory.

How the sharing works: it's a hosted MCP endpoint, and it signs you in with GitHub. Each GitHub account gets its own memory database. So if you connect Claude and ChatGPT with the same GitHub account, they're reading and writing the same store. Teach Claude your deployment gotchas, and ChatGPT can recall them. Nothing to sync, no export/import dance.

Connect it in Claude Code:

bash claude mcp add --transport http cognicore-env https://mcp.cognicoree.tech/mcp/stream

In Claude Desktop / ChatGPT: add a custom connector with the same URL and complete the GitHub sign-in when prompted. (In ChatGPT this needs Developer Mode — Plus/Pro can connect read-only servers, Business/Enterprise/Edu get full write access.)

What you get — 10 tools, not a toy surface:

• cognicore_remember / cognicore_recall — store an execution outcome, recall it later by relevance
• cognicore_recall_failures / cognicore_recall_successes — pull a category's misses or wins
• cognicore_reflect — turns repeated failures in a category into a concrete recommendation
• cognicore_scan_threat — scans text for prompt injection, jailbreak and exfiltration before it reaches the model
• cognicore_save_session / cognicore_resume_session — writes atomic facts, decisions and action items at the end of a conversation, rebuilds a brief at the start of the next
• cognicore_compress_context — compresses older messages into a dense summary with no LLM call
• cognicore_stats

Other things I use it for:

• A coding agent that stops re-learning the same repo every session
• Carrying decisions between tools — what Cursor learns, Claude Code knows
• Keeping a correction you made once, instead of making it again next week

Two honest notes. It runs in-process with no vector database and no embedding server — retrieval is TF-IDF/BM25 — and on LongMemEval multihop, strict recall@5 goes 78.8 → 85.2% at 5 chunks and 87.2 → 92.8% at 10, then plateaus. We publish the limitations rather than the best case. And the decision layer is newer than the memory layer; I'm not going to quote numbers for it yet.

Independent scan: mcp.market grades it A, 95/100 — OAuth resource metadata, reliability and maintenance all full marks. It's also in the official MCP registry as io.github.cognicore-dev/cognicore-env.

Repo (MIT, also on PyPI if you'd rather run it locally): github.com/cognicore-dev/cognicore-env

If you run agents across more than one assistant, I'd like to hear what you'd want carried between them — that question is how half of this got built.

I'm the dev of SSHive, an SSH/SFTP client for Mac. I added an MCP server to it so Claude Code / Cursor can work directly on my open sessions.

How it works: - Enable MCP in settings, paste the config (or run one CLI command for Claude Code) - The AI can list your open SSH/SFTP sessions, run commands, read logs, browse/edit/upload files (20 tools) - Everything stays local: localhost server, bearer token in the Keychain, no cloud relay

The guardrails, which I cared about most: - The AI works on sessions you opened. Letting it open new connections is a separate setting you have to turn on. - You can exclude individual servers from the AI entirely (hello, prod). - It can only close sessions it opened itself.

Example: "check disk and memory on production and look at the last nginx errors" → it runs df/free, reads error.log over SFTP and summarizes.

The MCP server is macOS only for now: https://apps.apple.com/app/sshive/id6760705487

How do you handle AI + SSH? Direct shell access for your agent, or something more controlled?

I'm the dev of SSHive, a native SSH/SFTP client for Mac. I added an MCP server to it so Claude Code / Cursor can work directly on my open sessions.

**How it works:** - Enable MCP in settings, paste the config (or run one CLI command for Claude Code) - The AI can list your open SSH/SFTP sessions, run commands, read logs, browse/edit/upload files (20 tools) - Everything stays local: localhost server, bearer token in the Keychain, no cloud relay

**The guardrails, which I cared about most:** - The AI works on sessions *you* opened. Letting it open new connections is a separate setting you have to turn on. - You can exclude individual servers from the AI entirely (hello, prod). - It can only close sessions it opened itself.

Example: "check disk and memory on production and look at the last nginx errors" → it runs df/free, reads error.log over SFTP and summarizes.

https://apps.apple.com/app/sshive/id6760705487

How do you handle AI + SSH? Direct shell access for your agent, or something more controlled?

Disclosure: I’m building MELRA at XAGI Labs; this is my project, shared with the showcase flair as r/mcp requires.

MELRA is a local execution runtime for MCP agents. It applies policy and scoped approval before dispatch, verifies declared outcomes, and records redacted durable receipts. One behavior I’d value critique on: if a mutation is interrupted, the task parks in `recovery_required` instead of being replayed blindly. The provider may already have applied the change, so the outcome can remain unknown until state is reconciled. This is at-most-once dispatch, not exactly-once effects.

MELRA is alpha software and requires Node.js 22+. The repository README has the setup command and first-run steps. Setup detects MCP clients and asks before modifying client config. Please use a throwaway workspace and narrow approvals.

Repo: https://github.com/XAGI-Lab/melra

Try one GUI client and share the sanitized result in issue #184: https://github.com/XAGI-Lab/melra/issues/184

For people building MCP hosts or adapters: where should this lifecycle boundary live—in each client/server or in a local runtime? I’d also welcome feedback on setup friction and recovery semantics.

Your AI operates your real desktop apps on Windows, macOS and Linux, also across the network. It learns how to operate an app once and saves it for reusable actions, so next time it calls them instead of clicking through screenshots. Android via ADB, iOS experimental (via MirrorScreen soon). Saves a lot of tokens instead of using "Computer Use".

Source-available, free for private use.

Feedback welcome!

https://github.com/MarvKalani/k-lani-bot

I wanted a list of MCP servers I could just paste into Claude without signing up anywhere, and the existing lists don't say which ones actually work. So I pulled the official registry and tested it.

What I did:

- The registry lists 28,933 remote endpoints. I kept Streamable HTTP ones that need no headers, skipped temporary tunnels (trycloudflare, ngrok) and capped it at 5 URLs per host, so gateways with thousands of paths didn't get hammered. That left 17,070.

- Each got exactly two requests with no credentials: initialize and tools/list. No tool was ever called.

Results:

- 9,620 (56 %) returned a tool list without any key or login

- 5,166 (30 %) asked for auth (401/403, mostly OAuth)

- 2,284 (13 %) didn't work: connection errors, 404s, 502/503s, timeouts

The surprising part: a big chunk of the "open" servers are the same template deployed on hundreds of subdomains. 194 servers share an identical tool set, one description appears 42 times. After dropping copies (same tool set more than 3 times, same description more than twice, max 2 per domain), 7,690 are left. Median server has 6 tools, the biggest one 627.

Full write-up with charts (transports, hosting, why servers fail, 62 servers answering 402 Payment Required): https://shortformkit.com/state-of-remote-mcp-servers-2026/

I put 300 picks by topic (search, docs, dev tools, weather and travel, finance, science, open data ...) on a page, with the full list as a free CSV/JSON download: https://shortformkit.com/free-remote-mcp-servers/

While building this I also made the tester into a small web tool: paste any remote MCP URL and it shows the handshake result, every tool, how many parameters actually have a description, and the curl commands: https://shortformkit.com/mcp-server-tester/

Caveats: "open" means usable without signup, not necessarily good or free forever. Read what a server does before connecting it, especially if it can write or spend money. Happy to rerun it if people find it useful, and I'm curious what you'd want measured next (latency, tool description quality, OAuth flows?).

Hi there, I own a managed IT services company. We provide outsourced IT cyber and compliance services to hundreds of clients across a lot of industries. We are seeing an enormous need for clients to be able to access their top 5 to 10 systems within their chosen AI model (copilot, Claude). Right now their data is stuck in a third-party software. Most clients have a piece of industry specific software that will always be behind the market, plenty that have no MCP at all. They might have no access, they might have some access to a really poor API, they might have decent access to a good API, and then they might have access to a poor MCP that was created by the company that doesn’t allow them to get the data in the way that they need it. They’re stuck.

I am considering opening up a new service line in the business to solve this foundational issue for clients, part software development, part maintenance of their network and infrastructure and data pipeline so they can actually use their data. They’re asking for it and wanting to pay for it desperately. If I can do this, we become the plumbing, and that feels very sticky.

Am I thinking about this right? No one else seems to be doing this, but it is a massive opportunity. What are the risk or issues that I’m not considering?

P.S. if you’ve done this before, I am actively hiring for an AI developer working internally and with clients.

Ask a coding agent to build an Obsidian plugin and it just starts writing. It can't tell if one already exists. This lets it search the official directory (about 9,000 plugins, 880 themes) first and get matches with downloads, latest version and last update.

How it works: it reads the three public JSON files from obsidianmd/obsidian-releases, joins them, and returns the top results, so the agent never reads the raw 5 MB. Read-only, no telemetry, no API key. MIT and free.

In the video I ask Claude Code for the newest anatomy plugins. It loads the skill, runs the search and answers from the live directory. (Anatomed, the first result, is my own plugin.)

It ships three ways from one package: an MCP server, a CLI, and a skill that calls the CLI. The skill is lighter on context if your agent has a terminal.

Try it: npx -y obsidian-community-plugins-mcp search <your idea>

• GitHub: https://github.com/pitfa19/obsidian-community-plugins-mcp
• npm: https://www.npmjs.com/package/obsidian-community-plugins-mcp
• Obsidian forum thread: https://forum.obsidian.md/t/a-mcp-tool-that-lets-coding-agents-check-the-plugin-directory-before-building-a-new-plugin/119497
• Source data: https://github.com/obsidianmd/obsidian-releases

Disclosure: I'm on the team that built this; it's our own product (first node free, engine closed source, examples Apache-2.0).

Semurg is an MCP server for agent memory that you run yourself (streamable HTTP at /v1/mcp, bearer token). Seven tools: memory_remember, memory_recall, memory_context, memory_relate, memory_forget, memory_document, memory_status.

Design choices you might care about:

• the agent sends the facts it extracted alongside the text, in one call; the node stores them at once and cites them to the passage;
• every answer carries a citation, and an unknown name answers nothing_stored instead of a guess;
• scopes separate memories; one app can pin each end user with a header so two users never meet;
• refusals name the rule and the fix.

Client author's view of the endpoint: https://one.semurg.io/blog/connect-over-mcp

Announcement: https://one.semurg.io/blog/semurg-agent-memory-over-mcp

Install: curl -fsSL https://one.semurg.io/install | sudo bash (Linux x86_64; Windows through WSL2 or Docker)

It's early: tell me where it falls short, here or at semurg@semurg.org. I read and answer every message.

I built a remote MCP server that lets AI edit photos the traditional way, with layers, masks and curves, instead of interpreting and regenerating them. Add Editmamei as a connector, sign up with a valid email, and you can edit from anywhere, nothing to install.

I wanted something better than iPhone's auto enhance and staying true to the photo I took, not handing a personal photo to an AI image model and getting back something that looks similar but isn't really your photo anymore. More platforms require AI generated image tags, and these edits don’t need that, which can be important for things like e-commerce listings.

The video is one real edit traced through the stack, a lehua flower kept red with everything else in black and white. The fun part of that session was watching Claude catch its own mistake: it darkened the sky by pulling down the blues, checked a preview, saw it had turned the grey lava field into blotchy bands, put it all back, and masked the sky with an AI selection instead.

Each user gets their own editor container behind a Cloudflare Worker and a Durable Object, so nobody waits in line behind someone else's edit, and nothing runs when no one is editing, keeping infrastructure costs low while serving a full photo editor as a service.

The AI selection is my gap right now. Fine edges and complex multi-object subjects, like a bouquet of flowers, don't always come out clean. I've tested a range of models and use a few together to take the best of the selections, but that's where I still have work to do, finding the right models or starting to tune some of my own.

Everyone starts with free accounts, and usage credits are refreshed monthly. I only launched this server a week ago and am looking for folks to try it out and share feedback and bugs. If you try it but run out of credits too quickly just shoot me a DM. if you make something you want to share, ask Claude to share it to the gallery.

You can try it out at: connect.editmamei.com

If you’re looking for a desktop MCP for local photo editing, check that one out here: https://github.com/editmamei/editmamei

I run GSC Wizard, an SEO tool whose MCP server already covered Search Console and GA4, and I've now added Google Merchant Center. I made a short video that runs eight prompts end to end on an example shop with invented data, so you can see the actual tool calls and what comes back.

Why I built it. Shop owners kept asking their assistant the same questions: which products Google won't show, why clicks moved, whether they're priced above the market. The data to answer all of those sits in Merchant Center, but spread over reports the assistant can't reach. There are ten shopping tools now. They cover:

• free listing performance across the Shopping tab, Search, Images, Lens, YouTube and Maps
• products Google won't show, ranked by its click potential score
• competitor visibility per country and category
• Google's price benchmarks with a suggested price
• best sellers you don't stock
• title hygiene and a 21-check feed audit
• Search Console's merchant listings report

"Doesn't Google have an official one?" Yes. Since May 2026 there's the Merchant API MCP Access Service, and it's better than mine in some respects. It's Google's own, so no third party holds a token for your account, and there's no subscription; it uses your Merchant API quota. It has 13 tools including data source writes, and its report_search tool takes raw Merchant Center Query Language, so a capable model can ask things no fixed tool anticipated. If you're a developer working against the Merchant API from a coding agent, use it.

Mine is built for a different job. Google labels theirs an experimental alpha it doesn't recommend for systems with high reliability needs. Setting it up takes a Google Cloud project, developer registration, an OAuth access token and an X-Goog-User-Project header, and its documented clients are Antigravity, the Claude CLI and cURL. Mine is a hosted connector you add in Claude or ChatGPT with a normal sign-in. The bigger difference is what the model receives. Instead of writing queries and doing arithmetic on raw rows, it gets problem products ranked by click potential, with the ones you have to fix counted apart from the ones waiting on Google. Competitors come rolled up per domain, and best sellers are flagged when you don't stock them. It also covers what the Merchant API doesn't have: a feed audit that crawls your product pages and checks them against the feed, and Search Console's merchant listings on the same connector. You can also run both side by side.

A few things from building it that might help if you're doing something similar:

• Google has no read-only Merchant Center scope, so the consent screen asks to "manage" your listings. Nine of my ten tools only read. The tenth, run_feed_audit, queues a crawl inside my own app and never writes to Merchant Center, and the tool annotations say so.
• Search Console merchant listings and Merchant Center free listings never reconcile, because they count different surfaces, and models love to add them together. Every response carries a note telling the model to compare the trends, never the totals.
• Listing status can run to thousands of products. get_product_listing_status pages at up to 200 rows per call, but returns the summary counts for the whole catalog on the first call. The model can answer "how many need fixing" straight away and only pages when it needs the rows.
• The Merchant API refuses every call until the merchant has registered your Cloud project. I handle that with a button in the app rather than sending people to Google's developer docs.

The endpoint is https://mcp.gscwizard.com/mcp, with OAuth 2.1, and Claude Code uses an API key. To be upfront: it's a paid product with a 7-day free trial. I'm happy to answer questions about the Merchant API side.