I Gave Claude Direct Write Access to My Gumroad Store

Every other “AI for your store” guide hands you a chatbot that writes product descriptions and calls it automation, same as handing an intern a legal pad and telling them they run the company. The agent I run doesn’t leave notes on my desk. It walks into Gumroad, fixes the busted landing page, digs out the dead product I’d buried and forgotten, flags the sale that broke and nobody caught, and tells me after, the way I’d want anybody I trusted with the register to.

The difference between that and the toy version is whether it has the keys, not how smart the model sounds. A tool that drafts something you still have to go paste into a dashboard is a suggestion box. A tool with a real connection into the store’s API is the person minding the register while you’re doing the work only you can do.

What it caught before I found it

I didn’t find the membership bug. It did.

Somewhere in a catalog I’ve built by hand over three years, a permission had been failing to fire every time someone bought the paid tier, and nothing anywhere said so. The sale went through, Gumroad took the money, the buyer got a receipt, and the actual access that receipt was supposed to unlock never got granted on my end.

Here’s the shape of it, because the shape is the whole lesson. Gumroad calls the same product by two different names: a short scrambled code it generates, and the readable slug you set when you name the thing. Months back I’d tightened a check that verifies every sale is real before it hands out access, a guard against somebody forging a receipt.

The guard matched on the readable name. The sales came in tagged with the short code. Every real buyer failed a test built to stop fake ones, and the failure was silent, because a security check that rejects a sale doesn’t ring a bell.

It just quietly does nothing.

Nobody complained loud enough to reach me directly. One buyer eventually mentioned it in passing, and by the time I went looking, the agent had already pulled the sale records, lined them up against the check, and found the mismatch. The fix was one line: match on the code that never changes instead of the name that does.

The fix that was making things safer was the thing that broke them.

I only know that because something was finally watching close enough to notice a silence. A dashboard I check when I remember to wouldn’t have caught it. Neither would a support ticket sitting three days in a queue.

The same connection that creates a product reads every sale as it clears, which means it can catch the one where nothing else did.

That’s the part the skeptics skip past. The scary version of “AI running your store” is a model going rogue and refunding your whole catalog by accident.

The actual failure mode I’ve hit is the opposite: a boring, entirely human mistake sitting in the plumbing for weeks, caught only because the thing watching didn’t get bored or distracted the way I would have.

Why now, specifically

Part of why this is worth writing now and not eighteen months ago: Gumroad got better right as the tooling to run it got good enough to hand off.

Sahil Lavingia stepped back from running the company day to day in November, kept a Chairman title and a board seat, and handed the actual keys to Ershad Kunnakkadan, an engineer who’d been building the guts of the place for eight years before anyone gave him the title. I don’t know if he jumped or got walked to the door, and I don’t much care. I hate that fucker, and watching him stop being the one making the calls is the best decision this company has made since it opened its doors.

Every change I’ve watched roll out since has moved one direction: faster, less precious about itself, more obviously built by people who care whether the person selling a nine-dollar PDF actually eats this month. The platform under all of this is finally being run by people who use it the way I do.

Good timing to inherit a house somebody’s taking care of.

The two doors in

The word “connection” hides a lot, and the rest of this doesn’t land until you know which kind I mean.

There are two doors, and they open onto the same room. The first is a command-line tool, the kind of thing that lives in a terminal and does exactly one thing when you type one line.

List my products. Refund that sale. Drop the price on this to nine dollars. It runs, it prints what it did, it stops. No daemon sitting there thinking on its own. A tool I run, or the agent runs on my say-so, one clean action at a time.

The second is a live wire, an MCP server, and the acronym won’t matter to you in a year. The command-line tool is handing someone a specific wrench when they ask for it. The live wire is giving them standing access to the whole workshop.

The agent doesn’t wait for me to pass it the pliers. It knows the pliers are on the pegboard, reaches for them when the job calls for it, and I read the receipt after.

Both doors talk to the same API Gumroad publishes for anybody who wants it. Neither one is a bot pretending to be a browser, clicking buttons on a page and praying the layout didn’t change overnight.

This is the store talking to the store’s own front desk, in the language the front desk was built to answer. That’s the whole reason it can move fast without breaking things a screen-clicker would break.

Everything it actually touches

Everything here is something the connection has done on my store or can do on command, described the way it works, not lifted from a features page. This is the part worth keeping open in a tab.

The catalog

A product on Gumroad isn’t one shape, and the connection makes all of them. A straight digital download. A membership that bills every month and cuts access when the card stops working. A pay-what-you-want with a floor, so the tip jar has a bottom. A bundle that wraps four separate products into one cheaper door, which is how the big everything-bundle on my store exists at all.

It’ll even stand up the odder types Gumroad allows, a tip, a booking, a commission, though my shelf is guides and stories so I’ve never had a reason to.

When it builds one, it sets all of it in a single pass: the price and currency, the readable slug that becomes the URL, the note the buyer sees on their receipt, a cap on how many can ever sell if I want the thing to feel scarce. Every new product lands as a draft. Nothing goes live on its own. It hands me the thing behind glass and I’m the one who opens the store.

Retagging is where three years of my own neglect shows up on an old catalog. Point it at the mess and it finds the product still sitting at a price I set two years ago and forgot, turns up the one with no category that’s been invisible to search this whole time, flags the tags that drifted out of any order that made sense. I had a lifetime tier once that turned into a hassle. I told it to pull the product and strip the tier off every page that mentioned it, and it did, cleanly, no orphaned links left behind.

Variants and the categories that hold them, a size, a tier, an edition, each with its own price bump and its own file, all built and edited in place instead of me digging through a settings menu I only half remember the shape of.

The thing the buyer actually downloads

The product page is the promise. The file is the thing. The connection uploads that file, swaps it for a new version without breaking the product or resetting anybody’s access, and hangs a different one on each variant when the tiers ship different things.

When an upload dies halfway on a bad connection, it can pick the pieces back up or clear the wreckage and start clean, which matters more than it sounds the first time a two-hundred-meg zip strands itself at ninety percent.

Landing pages and the look of the store

The first custom landing page it built for me rendered completely unstyled, every class name present and doing nothing, because Gumroad doesn’t inject the styling framework the way I’d assumed it would. One missing script tag, found and fixed the same afternoon, not three days later when I’d finally notice the page looked broken.

Custom HTML is its own small trapdoor, and the connection knows where the floor is. Gumroad runs every page you publish through a sanitizer that rewrites or strips anything it doesn’t trust, and it reads the report of what got changed instead of publishing blind and wondering why the page looks wrong.

The live fields are the real trick: you wire the price and the name and the buy button to the product itself, so a page can never sit there advertising a price you changed last month. You can even pre-load the checkout, a specific variant already selected, a quantity, a billing period, so the button does the thinking for the buyer.

Covers, thumbnails, the gallery of preview images, a YouTube clip dropped in as a cover, all set the same way: told what to do, shown the result, corrected on the spot when it’s wrong.

Money coming in

Every sale, readable. It lists them filtered by product, by buyer email, by a date window, hunts down the one purchase a specific customer is emailing you about, and pulls summaries grouped by day or week or month so I can see the shape of a launch without exporting anything. For the big ranges it asks Gumroad to mail me the full CSV instead of choking on ten thousand rows. No spreadsheet I build by hand, no math I’ll get wrong at eleven at night.

Money going out

Refunds, full or partial, though this is the one place the leash is shortest. A buyer emails, the agent reads the refund policy I wrote down in plain English months ago, checks the purchase against it, and either brings me a refund to sign off on or tells me exactly why it won’t. Either way there’s a receipt with my name nowhere on it.

It resends receipts to buyers who lost theirs. It builds and kills offer codes, a percent off or a flat few dollars, capped to a hundred uses or turned loose across the whole catalog, tested for a week and pulled if they’re not moving anything. And it sets the store-wide refund policy itself, the window and the fine print, seven days or thirty or none, the rule the refund decisions all answer to.

The people on the other end

Subscribers, the humans on a membership, listed and looked up by email when one of them writes in confused about a renewal. License keys, if a product hands them out, verified without burning a use, switched off when one leaks, rotated to a fresh key when somebody’s been sharing theirs around a Discord. There’s a small discipline the connection keeps here: a license key goes in through the back, never typed out on the command line where it’d end up sitting in a log forever. The kind of thing you only think to protect after it’s bitten someone.

Same with payouts. I ask what’s scheduled, what already landed, what’s still sitting in the pipe, down to the individual transactions if I want them, without logging into a dashboard I open maybe twice a month.

The plumbing you forget about until it breaks

Nobody gets excited about webhooks and custom fields. But a webhook is how the store tells my own systems the second a sale or a refund happens.

Custom fields are the extra questions a buyer answers at checkout. The account-level refund policy that governs every refund decision lives in this same unglamorous layer, configured and checked with the same attention as everything a customer can see.

This is the layer that caught the membership bug, because this is the layer where the membership bug lived.

Nobody builds a business plan around “check whether the webhook is still firing.” Somebody has to anyway.

What I still watch

None of this runs on autopilot, and I’d be lying if I said otherwise. The safety isn’t a promise the model makes. It’s built into how the doors are hung.

Anything destructive, a refund, a delete, a price cut on something already selling well, gets shown to me before it executes, not after. That’s a leash length I set on purpose, not a limitation I’m apologizing for.

New products come out as drafts, so the worst a bad idea can do is sit there unpublished. The keys to the store, the token that opens the whole thing, live outside the store itself, in a place the public web never touches, so the connection can use them without them ever being somewhere a visitor could find.

Even the license-key habit is a wall built on purpose.

It’s also not infallible. The membership bug is the proof of that, not evidence against it. Something was already broken before the agent ever touched the store. What changed is how long it stayed broken.

What it takes to stand one up

I won’t pretend this is a five-minute setup, because the honesty is the point. You generate a token in Gumroad’s settings, the one string that grants all of this, and you wire it into the tool.

Keep it somewhere safe and out of the store’s public reach. Guard it like a house key, because that’s what it is.

One trap to know before you hit it: on Gumroad, generating a new token revokes the old one. So the reflex of “make a new token to fix a login problem” kills every copy of the old one you forgot you had, and the thing that worked yesterday stops working for a reason that looks like nothing. Rotate on purpose, never as a panic move, and change it everywhere at once when you do.

If you’ve never touched an API token in your life, that whole paragraph reads like another language, and that’s the floor here.

This eats a weekend. It’s a real project, not a toggle you flip. But it’s a weekend that buys you a second set of eyes on your store that never blinks, and that trade has paid for itself on mine more than once.

Where to start

If you haven’t nailed the actual selling part yet, that comes first. Pricing low on purpose, building your own traffic instead of waiting on Gumroad’s discovery algorithm, all of that lives in how to sell digital products on Gumroad, and none of what’s above matters until that part’s working. Once it is, once there’s a catalog worth minding, that’s when handing someone the register starts paying for itself.

I still open the dashboard sometimes. Mostly to see if there’s anything left to do.

Related guides

The store is one system. Here’s the rest of the stack it plugs into, and the rule for using the machine without letting it use you.

• How to Sell Digital Products on Gumroad
• Writing With the Machine: Using AI Without Sounding Like Everyone Else
• Build a Creator OS You Actually Own