Unmetered*

For approved creators

Set up your studio.

About twenty minutes from a fresh account to a listing in review. The video walks through every screen; the steps below are the same in writing, with the packaging checklist our review uses.

Walkthrough video

Coming soon. The written steps below cover everything in it.

The steps, in order

  1. 1

    Create your account

    1 min

    Sign up from this page and the account is a creator studio from the first second; the page carries the invite. Use the email address you want buyers writing to, and pick a password you will keep.

    Sign up as a creator
  2. 2

    Secure it

    2 min

    Turn on two-factor in the studio's Security card. It keeps your payouts and listings yours even if your password leaks; the desk requires it for admins and recommends it for creators.

    Security
  3. 3

    Your profile

    3 min

    A real photo, a line or two on who you are and what you build, and your links. Buyers see this next to every tool you list and on the hire page. An agency can list under the agency's name.

    Profile
  4. 4

    Package your tool

    15 min

    Strip every secret and client-specific value, add .env.example and INSTALL.md, make it run from a fresh unzip, zip the project folder. The packaging kit below does this for you in Claude Code: one prompt packages it and ends with a plain-language confirmation, a second checks the finished zip before you upload, and the checklist is what our review checks first.

    Packaging kit
  5. 5

    Create the listing

    10 min

    Drop the LISTING.md the kit wrote and your zip on the New listing form: every field fills itself in (title, tagline, category, price, description, stack, what is included, requirements, running costs, the install guide and the Claude Code prompt), you edit what you like, and the zip goes in as version 1.0.0 when you save. Nothing reaches us yet: the version sits on your listing's card as uploaded until you submit it. Step 2 on the card is required before you can submit: at least one screenshot or a short demo video, and a couple of screenshots plus a demo do real selling. The demo goes in one of two ways: paste a Loom or YouTube share link and it embeds on the listing page, or press + upload a video file and choose the MP4 or WebM itself (under 100 MB); we host the file, keep a poster frame from it, and the listing page plays it in its own player. One demo at a time, and Remove video clears an uploaded one. Preview listing page in the card's header shows the page exactly as buyers will see it.

    New listing
  6. 6

    Submit for review

    1 min

    Step 4 at the bottom of the listing's card is Submit for review; nothing reaches us until you press it, so take your time with screenshots first. Pressing it is the moment your tool reaches us. From then on the listing is locked: details, screenshots and versions stay exactly as you submitted them until we decide, and the card shows the date it went in. Need to change something? Press Withdraw from review, edit, and submit again.

    Your listings
  7. 7

    Review

    we do this

    An automatic check runs the moment you upload: a zip without INSTALL.md or .env.example, with a real .env file, a key, node_modules or .git inside is set aside at once, the card says what to fix, and you get an email with the fix and the resubmit steps. Then a human reads the code and runs it, usually within two business days. Approved means live: the listing publishes in the same moment (with payouts connected) and you get an email with your share link. If something needs fixing you get exact notes, the listing unlocks, and a fixed version you upload and submit goes back to the front of the queue. The exact bytes we approve are what buyers get, frozen.

  8. 8

    Connect payouts

    5 min

    Stripe handles identity, bank details and tax forms. Each sale sits on a seven-day hold and then pays out to your bank on Stripe's schedule. A paid listing cannot publish until this is done; an approved one goes live the moment it completes. A free tool skips this gate and goes live on approval.

    Payouts
  9. 9

    Optional: take work for hire

    2 min

    Switch on Work for hire in the studio, pick what you take on (install, customise, extend, build, ongoing support), set a minimum project, add a booking link for calls, and choose whether new buyer requests are emailed to you. Buyers then see Hire next to Buy.

    Work for hire

Packaging checklist

  • Runs from a fresh clone by following the README, on a machine that has never seen it.
  • INSTALL.md with the steps in order, and a Claude Code prompt in the listing that does the same.
  • .env.example listing every variable with a placeholder, and no real values anywhere.
  • No client data, exports, logs, screenshots of accounts, or hardcoded keys in the tree.
  • One project folder at the root of the zip. Under 100 MB unpacked; under 3.5 MB also delivers straight into the buyer's GitHub.
  • If it needs a service to run (a database, a queue, a paid API), say so in Requirements with the expected monthly cost.

Package it with Claude Code

Open Claude Code at your project root and paste this. It reads the tree, finds secrets and client data, moves them to environment variables, writes .env.example, INSTALL.md and the buyer’s install prompt, tests a fresh unzip, zips the result, and hands you a report plus a LISTING.md that the studio's New listing form reads to fill itself in. It stops to ask whenever a decision is yours, and it never touches your real .env. A second prompt, run once the zip exists, checks the zip itself against the review list, fixes what is missing and prints a pass-or-fixed list, so nothing is sent back after upload.

Step 1: packaging prompt, paste at the project root

Twelve stages, about fifteen minutes on a typical tool. It ends with a plain-language confirmation of everything it did.

You are packaging this project so it can be sold on Unmetered as a downloadable zip. Buyers get the full source under a single-organization license and run it themselves, so the package must contain no secrets and no client data, and it must run from a fresh unzip by following INSTALL.md. Work from the project root. Never modify or delete my real .env file, and never print a secret value anywhere (the first 4 characters at most). Do not use em dashes in anything you write.

Work through these stages in order. After each stage, tell me what you found and changed before moving on, and stop to ask me whenever a decision is mine.

1. Understand it
Read the whole tree. Tell me in a few lines what this tool does, its entry points, how it is started, and which external services it calls. List every file over 1 MB.

2. Find every secret and every client-specific value
Search all text files, including config, scripts, notebooks, docs, tests, fixtures and CI files, for:
- Key patterns: AKIA followed by 16 characters, sk_live_ or sk_test_, whsec_, ghp_ gho_ ghu_ ghs_ ghr_, xoxb- xoxa- xoxp- xoxr- xoxs-, re_ followed by 20 or more characters, "BEGIN PRIVATE KEY", AIza followed by 35 characters, sk- followed by 32 or more characters (OpenAI and Anthropic keys), SG. (SendGrid), EAA (Meta), hf_, npm_, GOCSPX-, shpat_ and its siblings, Slack and Discord webhook URLs, JSON web tokens starting eyJ (a Supabase service-role key is one), and any long random string assigned to a name containing key, secret, token, password, passwd, pwd, auth, bearer, credential, client_secret, dsn or connection string, plus URLs of the form user:password@host.
- Files that hold credentials: .env and any .env.* other than .env.example, *.pem, *.p12, *.key, *.pfx, service-account*.json, credentials*.json, .npmrc, .netrc, .htpasswd, kubeconfig, terraform state, saved cookies or session files.
- Client-specific values: account ids, ad account ids, property ids, spreadsheet or document ids, Slack channel or workspace ids, customer or employee names and emails, client domains, internal URLs, database names, and anything named after a specific customer.
- Data: exports, CSVs, SQL dumps, logs, caches, screenshots, recordings, notebook outputs, and sample data that came from real accounts.
Report the full list with file paths.

3. Strip and generalise
For each finding:
- Real secrets: move the value to an environment variable read at runtime, replace the hardcoded value in the source, and add the variable to .env.example with a placeholder and a one-line comment on where to get it. Delete credential files from the tree.
- Client-specific ids and names: turn them into environment variables or a small config file with example values, or delete them if the tool does not need them. Replace real sample data with small synthetic samples.
- Live systems: if this copy is wired to my own databases, workspaces, spreadsheets or accounts, it is the copy that ships: duplicate anything that holds data, point every connection at placeholders in .env.example, delete seeded rows, client records and uploads, and leave migrations or a setup script so a buyer can create their own empty instance.
- Git history: tell me whether any of these values were ever committed, so I can rotate them. Do not rewrite history.
Ask me before deleting anything you are not certain about.

4. Remove what should not ship
node_modules, vendor and virtualenv folders, .git, build output (dist, build, .next, out, target, __pycache__, .pytest_cache), coverage, caches, OS and editor files (.DS_Store, Thumbs.db, .idea, and .vscode unless it holds project settings), and any archive or binary over 1 MB the tool does not need to run. Add or update .gitignore to match. Check the dependency licenses and tell me about any GPL, AGPL or LGPL package: copyleft dependencies need a decision from me.

5. Write .env.example
Every environment variable the tool reads, in the order a buyer will fill them in. Each entry is a comment line saying what the variable is for, whether it is required or optional, and the exact place to get it (a URL where possible), followed by NAME=placeholder. No real values. Variables the host sets on its own (PORT, RAILWAY_* and the like) get a comment line saying so rather than a value, and the code must treat a placeholder value from this file as unset, never as configured.

6. Write INSTALL.md
A numbered guide for a buyer who has just unzipped the folder and has never seen the code:
- Prerequisites with exact versions (runtime, package manager, CLI tools) and the command to check each.
- Accounts and keys they need, where to get each, and which permissions or scopes to grant.
- Install commands, copied exactly.
- Configuration: copy .env.example to .env and fill each value, referring to the comments.
- How to run it: the command for a one-off run and, if relevant, on a schedule or as a service.
- How they will know it worked: the exact output or screen they should see the first time.
- The five most likely errors and the fix for each.
- Where the moving parts are, so they can customise it: the main files and what each does.
Plain markdown, short sentences, no hype, no em dashes.

7. Write README.md if there is none
One paragraph on what it does and who it is for, a short feature list, and a pointer to INSTALL.md. Leave an existing README in place and only fix what is now wrong.

8. Write the buyer's Claude Code prompt
Save it as CLAUDE-INSTALL-PROMPT.md at the project root. It is a single prompt, addressed to Claude Code in the second person, that a buyer runs from inside the unzipped folder. It must tell Claude Code to read README.md and INSTALL.md, check the prerequisites, install the dependencies, create .env from .env.example by asking the buyer for each value one at a time (never guessing or inventing a key), start the tool, confirm it works using the check from INSTALL.md, and fix the common errors if they appear. Put only the prompt text in that file. I will paste it into the listing.

9. Fresh-unzip test
Copy the tree to a temporary folder, excluding everything from stage 4 and my .env, then follow INSTALL.md literally with a fresh .env made from .env.example, using dummy values where a real key is required. Every step that surprised you, or that you had to do and INSTALL.md did not say, goes into INSTALL.md. Report what you ran and what happened.

10. Final scan and zip
Run the stage 2 search again over the folder that will ship and confirm there are zero findings. Confirm there is no .env other than .env.example, no node_modules and no .git. Then, from the parent directory, zip the project folder so the zip contains one top-level folder, excluding the same files, and tell me the command you used, the zip size and the unpacked size. Unpacked must stay under 100 MB; under 3.5 MB lets buyers receive it straight into their own GitHub.

11. Report
Write PACKAGING-REPORT.md next to the zip, not inside it: every secret found (name and file, value redacted), every file removed, every variable in .env.example, the license check, the test result, the sizes, and the decisions you need from me.

12. Prepare the listing
Write LISTING.md next to the zip, not inside it. The studio's New listing form reads this file and fills itself in, and the listing page builds its search title and snippet from the title and tagline, so write for the buyer who is searching, not for yourself. First decide the two or three phrases a buyer would type to find a tool like this (what it does plus who it is for, and the subscription it replaces, for example "influencer content approval tool", "creator management portal for agencies", "Lifetimely alternative"). Then use exactly these level-2 headings, in this order, one per field: ## Title, ## Tagline, ## Category, ## Description, ## Stack, ## What is included, ## Requirements, ## Running costs, ## Install guide, ## Claude Code prompt, ## Suggested price, ## Search phrases. Title: the name a buyer would recognise, built on the main phrase's noun, under 40 characters (a project codename is not a title). Tagline: one line under 35 characters that pairs the main phrase with the benefit; title and tagline together must stay under 48 characters, because that is what the listing page puts in the browser title, and the tagline is also the first line of the search snippet and the catalog card. Category: exactly one of client-reporting, seo, paid-ads, social-media, email-and-crm, analytics, agency-operations, ai-agents, automation, starters. Description: the first sentence contains the main phrase and who it is for; the second names the subscription or manual process it replaces and what changes once it runs; then three to five bullet points of concrete capabilities that use the other phrases naturally, no hype, no keyword stuffing. Stack: one line, comma separated. What is included: one item per line, from a buyer's point of view. Requirements: one sentence, with runtime and version, accounts and keys, and setup time. Running costs: one line per paid service, as Service: rough monthly figure, required or optional, the figure part under 100 characters. Under Install guide and Claude Code prompt put the full text of INSTALL.md and CLAUDE-INSTALL-PROMPT.md inside a fenced code block (three backticks, then markdown) so their own headings are not read as fields. Suggested price: one number on the first line, then two sentences of reasoning for a one-time purchase of the full source under a single-organization license. Search phrases: the phrases you chose, one per line; the form ignores this section, it is for the creator's own announcement and blog post. Then summarise the report here in ten lines or fewer and tell me to drop LISTING.md and the zip on the studio's New listing form.

End with a confirmation I can read without knowing code: a bullet list of every file you added, changed or removed; the names (never the values) of the secrets moved to environment variables; the files left out of the zip; the zip path and its sizes; and one line each saying present or missing for INSTALL.md, .env.example, README.md and CLAUDE-INSTALL-PROMPT.md inside the zip, and LISTING.md next to it.

Step 2: audit the zip before you upload it

Run it once the zip exists. It unzips a copy, checks the twelve items the review looks for, fixes what fails, re-zips, and prints pass or fixed next to each.

You are checking a zip I am about to upload to Unmetered, where buyers get the full source and run it themselves. The zip is next to this project folder; if you cannot find it, ask me for the path. Unzip it to a temporary folder and check every item below against what is actually inside the zip, not against the project on disk. Never modify or delete my real .env file, and never print a secret value. Do not use em dashes in anything you write.

1. One top-level folder, with the project (source and package files) inside it.
2. INSTALL.md at the root of that folder: prerequisites with versions, accounts and keys with where to get each, install, configure, run, a first check, common errors.
3. .env.example at the root, listing every variable the code reads with a placeholder and a comment and no real values. Grep the source for every environment variable name and confirm each one is listed.
4. README.md at the root.
5. CLAUDE-INSTALL-PROMPT.md at the root, the buyer's one-paste install prompt.
6. No .env and no other credential file: .pem, .p12, .key, .pfx, service-account*.json, credentials*.json, .npmrc, .netrc, saved cookies or sessions.
7. No hardcoded keys or tokens anywhere: AKIA followed by 16 characters, sk_live_ or sk_test_, whsec_, ghp_ and friends, xoxb-, re_ followed by 20 or more characters, BEGIN PRIVATE KEY, AIza, and any long random string assigned to a name containing key, secret, token, password or auth.
8. No client-specific values: account or property ids, spreadsheet or document ids, customer names or emails, client domains, internal URLs, real sample data, exports, logs, screenshots of accounts.
9. If the tool was wired to my own databases, workspaces or accounts: every connection points at a placeholder, no seeded or client data ships, and a buyer can connect their own.
10. No node_modules, .git, build output (dist, build, .next, out, target, __pycache__), caches or OS files.
11. Under 100 MB unpacked.
12. LISTING.md next to the zip, not inside it, in the Unmetered format from the packaging prompt; write it if it is missing.

Fix every failure in the project folder, re-zip it from the parent directory so the zip holds one top-level folder, leaving out node_modules, .git, .env and build output, and tell me the new zip path. Finish with a confirmation: the twelve checks with pass or fixed next to each, every file you added, changed or removed, and the names (never the values) of any secrets you moved.
Doing it by hand, or checking its work
  1. 01

    Work on a copy

    Copy the project to a fresh folder and package that, so your working setup and its .env stay untouched.

  2. 02

    Find every secret and client value

    Run the search below from the copy's root. Then read the results with a second question in mind: does anything name a client, an account id, a spreadsheet, a Slack channel, a customer? Exports, logs, screenshots and real sample data count too.

  3. 03

    Move secrets to environment variables

    Every real value becomes a variable the code reads at runtime, and a line in .env.example with a placeholder plus a comment on where to get it. Delete credential files. If a key was ever committed to git, rotate it.

  4. 04

    Delete what should not ship

    node_modules, .git, build output, caches, .DS_Store, and any big binary the tool does not need. Under 100 MB unpacked; under 3.5 MB also delivers straight into the buyer's GitHub.

  5. 05

    Write INSTALL.md

    Numbered, from unzip to a working run, for someone who has never seen the code. Use the skeleton below. If it needs a paid service, say so with the expected monthly cost.

  6. 06

    Write the buyer's Claude Code prompt

    The prompt below fits most tools. Change the first line to name yours, paste it into the listing's Claude Code prompt field, and paste INSTALL.md into the Install guide field.

  7. 07

    Test a fresh unzip

    Unzip the package somewhere new and follow INSTALL.md word for word with a blank .env. Every step you had to improvise goes back into INSTALL.md.

  8. 08

    Zip and upload

    Zip from the parent folder so the archive holds one project folder, run the search once more on the unzipped result, then upload it in the studio as version 1.0.0 with a changelog line. Then the listing: the Claude Code route writes LISTING.md, and dropping it on the studio's New listing form with the zip fills every field and sends the zip in as version 1.0.0. By hand, type the description, category, stack, what is included, requirements, install guide and Claude Code prompt into the same form.

Secret and credential search

The same patterns our review scan uses, plus the usual generic ones. Run from the copy's root.

grep -rInE "AKIA[0-9A-Z]{16}|sk_(live|test)_[A-Za-z0-9]{20,}|whsec_[A-Za-z0-9]{20,}|gh[pousr]_[A-Za-z0-9]{30,}|xox[baprs]-[A-Za-z0-9-]{10,}|re_[A-Za-z0-9_]{20,}|BEGIN [A-Z ]*PRIVATE KEY|AIza[0-9A-Za-z_-]{35}|sk-(ant-)?[A-Za-z0-9_-]{32,}|SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}|EAA[A-Za-z0-9]{60,}|hf_[A-Za-z0-9]{30,}|npm_[A-Za-z0-9]{36}|GOCSPX-[A-Za-z0-9_-]{20,}|shp(at|ca|pa|ss)_[0-9a-fA-F]{32}|hooks\.slack\.com/services/|discord(app)?\.com/api/webhooks/|eyJ[A-Za-z0-9_-]{10,}\.eyJ|(postgres|postgresql|mysql|mongodb|redis|amqp)[a-z+]*://[^ ]+:[^ @]+@|(api[_-]?key|secret|token|password|passwd|client_secret)[\"']?\s*[:=]\s*[\"'][^\"']{8,}" --exclude-dir=node_modules --exclude-dir=.git . ; find . \( -name ".env*" ! -name ".env.example" -o -name "*.pem" -o -name "*.p12" -o -name "*.key" -o -name "*.pfx" -o -name "service-account*.json" -o -name "credentials*.json" -o -name ".npmrc" -o -name ".netrc" \) -not -path "*/node_modules/*"

INSTALL.md skeleton

# Install <tool name>

## 1. Prerequisites
- Node 20 or newer. Check with: node -v
- <any CLI or service, with the check command>

## 2. Accounts and keys
- <SERVICE> API key: where to create it, which permissions to grant.

## 3. Install
npm install

## 4. Configure
Copy .env.example to .env and fill in each value. The comments say where each one comes from.

## 5. Run
npm start
(also: how to run it on a schedule or as a service, if that is how it is meant to be used)

## 6. Check it worked
The first run should print or show: <exact output or screen>

## 7. Common errors
- "<error text>": <fix>
- "<error text>": <fix>

## 8. Where things are
- src/index.ts: <what it does>
- src/<file>: <what it does>

Buyer's Claude Code prompt

Goes in the listing's Claude Code prompt field.

You are setting up a tool I just bought on Unmetered; we are inside its unzipped folder. Read README.md and INSTALL.md first and follow INSTALL.md step by step. Check every prerequisite and tell me what is missing before installing anything. Install the dependencies. Create .env from .env.example and ask me for each value one at a time, explaining where to get it if I do not have it; never guess or invent a key. Start the tool and confirm it works using the check described in INSTALL.md. If something fails, read the error, fix it when it is in the code or the configuration, and tell me plainly when it needs something from me.

Zip command

Replace my-tool with your folder name. The last line prints the file count and unpacked size.

cd .. && zip -r my-tool-1.0.0.zip my-tool -x "my-tool/node_modules/*" "my-tool/.git/*" "my-tool/.env" "my-tool/.env.*" "my-tool/dist/*" "my-tool/build/*" "my-tool/.next/*" "my-tool/*/.DS_Store" "my-tool/.DS_Store" && unzip -l my-tool-1.0.0.zip | tail -1

Pulling a tool out of a bigger codebase

Start a fresh folder and copy in only what the tool needs to run. Replace imports from your shared code with local copies, delete anything that names a client, and run it once from scratch by following your own README. If a step surprised you, it goes in INSTALL.md. Then zip the folder. Most first listings are a few hundred files; if yours is far bigger, the part buyers want is probably smaller than the repo it lives in.

Pricing it

Price it like a purchase, not a subscription. Ask what a subscriber would pay you over the months they would actually stay, then charge roughly that once: three to six months of a monthly price is the usual range, and most first listings land between $29 and $499. Buyers keep it forever, so the number can be higher than one month and still feel obvious. You can add a paid upgrade for a major version later, and hire work is priced per contract.

Fees are on one page: 10% commission, 0% on your first $10,000 as a founding creator, and buyers pay a 5% fee on top of your price.

Questions creators ask

How long does review take?
Usually two business days from the moment you press Submit for review; uploading alone does not start it. You are emailed either way, with exact notes if something needs fixing. Fix, upload a new version, submit again, and it goes back to the front of the queue.
Can I edit a listing while it is in review?
No. Submitting locks the details, screenshots and versions until we decide, so what we read is exactly what goes live. Press Withdraw from review on the card to unlock it, make the change, and submit again.
When do I get paid?
Buyers pay at checkout. Your share lands in your Stripe balance with a seven-day hold, then pays out on Stripe's schedule. Founding creators pay 0% commission on their first $10,000; after that it is 10%. Buyers pay a 5% fee on top of your price, so your price is your price.
What if a buyer needs help?
Buyers can reply to their receipt or file a support claim from their library. If a tool does not run as described we make it right within seven days, which usually means you answer a question or ship a fix as a new version.
Loom link or video file?
Either. A Loom or YouTube link embeds on the listing page with nothing to upload; a file (MP4 or WebM, under 100 MB) plays in our own player with a poster frame taken from the clip, loads only when a buyer presses play, and stays on the page. Keep it short either way: two or three minutes of the tool doing its job beats a tour of every screen.
Can I ship updates?
Yes. Upload a new version with a changelog and submit it for review; once approved, every buyer is told and can download it or pull it into their GitHub as a pull request. You can also set an upgrade price for a major version.
What about my own clients?
Your existing clients are yours. Unmetered only takes a cut of sales and contracts that start here, and the 24-month rule covers people you met through the platform.
What can I sell?
Software you actually run: scripts, dashboards, integrations, internal tools, small apps. It does not need logins, billing or a brand. Buyers get the source under a single-organization license and run it themselves.

Stuck on any step? Reply to your approval email and a founder walks you through it.