Hey if someone building an adult business and finding a domain, I have lustroad.com. Hit me if u r interested.

Registrar: godaddy
Expiry : 8 months from now.

I needed to send ~80 personalized emails to a list of GitHub users a few weeks ago. Different name in each one, different repo reference, written like a person wrote them. The kind of thing you do when you're cold-reaching for a side project.

Every guide I found told me to sign up for SendGrid, Postmark or Resend. Verify a domain, set up DKIM, get on a free tier, hope you don't trip a spam classifier. Half a day of setup for something I needed to do once.

Then I remembered Gmail does this natively. Google has been running an SMTP server at smtp.gmail.com for twenty years and any language with a sockets library can talk to it. The only thing standing between you and sending email from your own Gmail is one settings page most people never visit.
Here's the whole thing.

What you need

A Gmail account with 2-Step Verification turned on. If you don't have 2FA on, go to myaccount.google.com/security and switch it on first, otherwise the next step doesn't exist.

Then go to myaccount.google.com/apppasswords and generate a new app password. Google shows you the 16-character string once, looks like abcd efgh ijkl mnop. Copy it immediately. The spaces are optional, Gmail accepts it either way. Treat this like a password — don't commit it, don't paste it in chat, don't put it in a Notion doc your team can read. Google's scanners catch app passwords leaked in public repos and auto-revoke them, but the lag is unspecified and you really don't want to find out the hard way.

That's it for setup. Now you can send email.

The minimal version

Ten lines of Python. No libraries beyond the standard library.

python
import smtplib
from email.message import EmailMessage

msg = EmailMessage()
msg["From"] = "you@gmail.com"
msg["To"] = "recipient@example.com"
msg["Subject"] = "hello"
msg.set_content("Body goes here.")

with smtplib.SMTP("smtp.gmail.com", 587) as smtp:
smtp.starttls()
smtp.login("you@gmail.com", "abcd efgh ijkl mnop")
smtp.send_message(msg)
Run it. An email leaves your Gmail and shows up in the recipient's inbox a few seconds later, looking exactly like one you typed by hand. That's the whole protocol. Everything else is wrapping that in a workflow.

If port 587 is blocked on your network (corporate Wi-Fi, some hotels), switch to port 465 with smtplib.SMTP_SSL instead of STARTTLS. Same protocol, different transport, one line change.

The pattern for sending to a list

For real outreach you need three files: a .env for the Gmail address and app password, a recipients.csv with name and email columns, and a template.txt where the first line is the subject and the body uses {name} placeholders. The script reads all three, renders an email per recipient, has a dry-run flag that prints everything without sending, asks for a y confirmation if it's a live send, and then sends one at a time with a 4-second delay between each.

The dry-run flag matters more than it sounds. The number one mistake is a typo in your template — {nmae} instead of {name} — and Python's string formatter will quietly send the literal {nmae} to all 80 recipients. A dry-run that prints every rendered email to your terminal catches this in five seconds and saves you the apology email. Always dry-run first.

The whole script is about 120 lines of stdlib Python. I keep the working version saved as an npad here: https://npad.run/p/how-to-send-emails-using-gmail-programmatically-sgkbrkxaxs. If you have Claude Code or Cursor, paste that URL and tell your agent to set this up. It'll write the script, the env, the CSV format, and the template. One shot, no copy-pasting from this article.

Things to know before you live-send

A few things I learned the slightly painful way that aren't obvious from the docs.

Send one email per recipient, not one BCC'd to everyone. BCC blasts look like spam to filters, and some email clients reveal the BCC list anyway, which is how you accidentally show 50 strangers each other's addresses. Sending one at a time means each person sees only their own address and it looks like you actually wrote to them.

Put a real delay between sends. 4–5 seconds is the sweet spot. Faster and Gmail starts returning 421 4.7.0 errors that mean "you look like a bot, slow down." Don't try to be clever about parallelism — Gmail's free tier wants quiet, polite traffic, not a burst of fifty messages in three seconds.

Add a confirmation prompt before sending. "About to send to 80 recipients. Continue? [y/N]" is the cheapest insurance you'll ever write. The day you accidentally point the script at the wrong CSV, that prompt is what saves you.

Limits

Free Gmail will let you send around 500 emails per day before it starts pushing back. Workspace bumps that to 2,000. If you need more than that, you're at the volume where SendGrid or Postmark actually starts to make sense — they exist because at scale you do need bounce handling, deliverability monitoring, and a warmed-up sender reputation. But for under 500 emails a day of personalized outreach, Gmail is genuinely fine. Better than fine actually — it lands in inboxes more reliably than a cold ESP IP because Gmail has spent twenty years building sender trust on its own infrastructure.

btw if you really want to push past the daily cap, you can rotate keys across multiple Gmail accounts. hehe.

I needed to send ~80 personalized emails to a list of GitHub users a few weeks ago. Different name in each one, different repo reference, written like a person wrote them. The kind of thing you do when you're cold-reaching for a side project.

Every guide I found told me to sign up for SendGrid, Postmark or Resend. Verify a domain, set up DKIM, get on a free tier, hope you don't trip a spam classifier. Half a day of setup for something I needed to do once.

Then I remembered Gmail does this natively. Google has been running an SMTP server at smtp.gmail.com for twenty years and any language with a sockets library can talk to it. The only thing standing between you and sending email from your own Gmail is one settings page most people never visit.
Here's the whole thing.

What you need

A Gmail account with 2-Step Verification turned on. If you don't have 2FA on, go to myaccount.google.com/security and switch it on first, otherwise the next step doesn't exist.

Then go to myaccount.google.com/apppasswords and generate a new app password. Google shows you the 16-character string once, looks like abcd efgh ijkl mnop. Copy it immediately. The spaces are optional, Gmail accepts it either way. Treat this like a password — don't commit it, don't paste it in chat, don't put it in a Notion doc your team can read. Google's scanners catch app passwords leaked in public repos and auto-revoke them, but the lag is unspecified and you really don't want to find out the hard way.

That's it for setup. Now you can send email.

The minimal version

Ten lines of Python. No libraries beyond the standard library.

python
import smtplib
from email.message import EmailMessage

msg = EmailMessage()
msg["From"] = "you@gmail.com"
msg["To"] = "recipient@example.com"
msg["Subject"] = "hello"
msg.set_content("Body goes here.")

with smtplib.SMTP("smtp.gmail.com", 587) as smtp:
smtp.starttls()
smtp.login("you@gmail.com", "abcd efgh ijkl mnop")
smtp.send_message(msg)
Run it. An email leaves your Gmail and shows up in the recipient's inbox a few seconds later, looking exactly like one you typed by hand. That's the whole protocol. Everything else is wrapping that in a workflow.

If port 587 is blocked on your network (corporate Wi-Fi, some hotels), switch to port 465 with smtplib.SMTP_SSL instead of STARTTLS. Same protocol, different transport, one line change.

The pattern for sending to a list

For real outreach you need three files: a .env for the Gmail address and app password, a recipients.csv with name and email columns, and a template.txt where the first line is the subject and the body uses {name} placeholders. The script reads all three, renders an email per recipient, has a dry-run flag that prints everything without sending, asks for a y confirmation if it's a live send, and then sends one at a time with a 4-second delay between each.

The dry-run flag matters more than it sounds. The number one mistake is a typo in your template — {nmae} instead of {name} — and Python's string formatter will quietly send the literal {nmae} to all 80 recipients. A dry-run that prints every rendered email to your terminal catches this in five seconds and saves you the apology email. Always dry-run first.

The whole script is about 120 lines of stdlib Python. I keep the working version saved as an npad here: https://npad.run/p/how-to-send-emails-using-gmail-programmatically-sgkbrkxaxs. If you have Claude Code or Cursor, paste that URL and tell your agent to set this up. It'll write the script, the env, the CSV format, and the template. One shot, no copy-pasting from this article.

Things to know before you live-send

A few things I learned the slightly painful way that aren't obvious from the docs.

Send one email per recipient, not one BCC'd to everyone. BCC blasts look like spam to filters, and some email clients reveal the BCC list anyway, which is how you accidentally show 50 strangers each other's addresses. Sending one at a time means each person sees only their own address and it looks like you actually wrote to them.

Put a real delay between sends. 4–5 seconds is the sweet spot. Faster and Gmail starts returning 421 4.7.0 errors that mean "you look like a bot, slow down." Don't try to be clever about parallelism — Gmail's free tier wants quiet, polite traffic, not a burst of fifty messages in three seconds.

Add a confirmation prompt before sending. "About to send to 80 recipients. Continue? [y/N]" is the cheapest insurance you'll ever write. The day you accidentally point the script at the wrong CSV, that prompt is what saves you.

Limits

Free Gmail will let you send around 500 emails per day before it starts pushing back. Workspace bumps that to 2,000. If you need more than that, you're at the volume where SendGrid or Postmark actually starts to make sense — they exist because at scale you do need bounce handling, deliverability monitoring, and a warmed-up sender reputation. But for under 500 emails a day of personalized outreach, Gmail is genuinely fine. Better than fine actually — it lands in inboxes more reliably than a cold ESP IP because Gmail has spent twenty years building sender trust on its own infrastructure.

btw if you really want to push past the daily cap, you can rotate keys across multiple Gmail accounts. hehe.

I needed to send ~80 personalized emails to a list of GitHub users a few weeks ago. Different name in each one, different repo reference, written like a person wrote them. The kind of thing you do when you're cold-reaching for a side project.

Every guide I found told me to sign up for SendGrid, Postmark or Resend. Verify a domain, set up DKIM, get on a free tier, hope you don't trip a spam classifier. Half a day of setup for something I needed to do once.

Then I remembered Gmail does this natively. Google has been running an SMTP server at smtp.gmail.com for twenty years and any language with a sockets library can talk to it. The only thing standing between you and sending email from your own Gmail is one settings page most people never visit.
Here's the whole thing.

What you need

A Gmail account with 2-Step Verification turned on. If you don't have 2FA on, go to myaccount.google.com/security and switch it on first, otherwise the next step doesn't exist.

Then go to myaccount.google.com/apppasswords and generate a new app password. Google shows you the 16-character string once, looks like abcd efgh ijkl mnop. Copy it immediately. The spaces are optional, Gmail accepts it either way. Treat this like a password — don't commit it, don't paste it in chat, don't put it in a Notion doc your team can read. Google's scanners catch app passwords leaked in public repos and auto-revoke them, but the lag is unspecified and you really don't want to find out the hard way.

That's it for setup. Now you can send email.

The minimal version

Ten lines of Python. No libraries beyond the standard library.

python
import smtplib
from email.message import EmailMessage

msg = EmailMessage()
msg["From"] = "you@gmail.com"
msg["To"] = "recipient@example.com"
msg["Subject"] = "hello"
msg.set_content("Body goes here.")

with smtplib.SMTP("smtp.gmail.com", 587) as smtp:
smtp.starttls()
smtp.login("you@gmail.com", "abcd efgh ijkl mnop")
smtp.send_message(msg)
Run it. An email leaves your Gmail and shows up in the recipient's inbox a few seconds later, looking exactly like one you typed by hand. That's the whole protocol. Everything else is wrapping that in a workflow.

If port 587 is blocked on your network (corporate Wi-Fi, some hotels), switch to port 465 with smtplib.SMTP_SSL instead of STARTTLS. Same protocol, different transport, one line change.

The pattern for sending to a list

For real outreach you need three files: a .env for the Gmail address and app password, a recipients.csv with name and email columns, and a template.txt where the first line is the subject and the body uses {name} placeholders. The script reads all three, renders an email per recipient, has a dry-run flag that prints everything without sending, asks for a y confirmation if it's a live send, and then sends one at a time with a 4-second delay between each.

The dry-run flag matters more than it sounds. The number one mistake is a typo in your template — {nmae} instead of {name} — and Python's string formatter will quietly send the literal {nmae} to all 80 recipients. A dry-run that prints every rendered email to your terminal catches this in five seconds and saves you the apology email. Always dry-run first.

The whole script is about 120 lines of stdlib Python. I keep the working version saved as an npad here: https://npad.run/p/how-to-send-emails-using-gmail-programmatically-sgkbrkxaxs. If you have Claude Code or Cursor, paste that URL and tell your agent to set this up. It'll write the script, the env, the CSV format, and the template. One shot, no copy-pasting from this article.

Things to know before you live-send

A few things I learned the slightly painful way that aren't obvious from the docs.

Send one email per recipient, not one BCC'd to everyone. BCC blasts look like spam to filters, and some email clients reveal the BCC list anyway, which is how you accidentally show 50 strangers each other's addresses. Sending one at a time means each person sees only their own address and it looks like you actually wrote to them.

Put a real delay between sends. 4–5 seconds is the sweet spot. Faster and Gmail starts returning 421 4.7.0 errors that mean "you look like a bot, slow down." Don't try to be clever about parallelism — Gmail's free tier wants quiet, polite traffic, not a burst of fifty messages in three seconds.

Add a confirmation prompt before sending. "About to send to 80 recipients. Continue? [y/N]" is the cheapest insurance you'll ever write. The day you accidentally point the script at the wrong CSV, that prompt is what saves you.

Limits

Free Gmail will let you send around 500 emails per day before it starts pushing back. Workspace bumps that to 2,000. If you need more than that, you're at the volume where SendGrid or Postmark actually starts to make sense — they exist because at scale you do need bounce handling, deliverability monitoring, and a warmed-up sender reputation. But for under 500 emails a day of personalized outreach, Gmail is genuinely fine. Better than fine actually — it lands in inboxes more reliably than a cold ESP IP because Gmail has spent twenty years building sender trust on its own infrastructure.

btw if you really want to push past the daily cap, you can rotate keys across multiple Gmail accounts. hehe.

I needed to send ~80 personalized emails to a list of GitHub users a few weeks ago. Different name in each one, different repo reference, written like a person wrote them. The kind of thing you do when you're cold-reaching for a side project.

Every guide I found told me to sign up for SendGrid, Postmark or Resend. Verify a domain, set up DKIM, get on a free tier, hope you don't trip a spam classifier. Half a day of setup for something I needed to do once.

Then I remembered Gmail does this natively. Google has been running an SMTP server at smtp.gmail.com for twenty years and any language with a sockets library can talk to it. The only thing standing between you and sending email from your own Gmail is one settings page most people never visit.
Here's the whole thing.

What you need

A Gmail account with 2-Step Verification turned on. If you don't have 2FA on, go to myaccount.google.com/security and switch it on first, otherwise the next step doesn't exist.

Then go to myaccount.google.com/apppasswords and generate a new app password. Google shows you the 16-character string once, looks like abcd efgh ijkl mnop. Copy it immediately. The spaces are optional, Gmail accepts it either way. Treat this like a password — don't commit it, don't paste it in chat, don't put it in a Notion doc your team can read. Google's scanners catch app passwords leaked in public repos and auto-revoke them, but the lag is unspecified and you really don't want to find out the hard way.

That's it for setup. Now you can send email.

The minimal version

Ten lines of Python. No libraries beyond the standard library.

python
import smtplib
from email.message import EmailMessage

msg = EmailMessage()
msg["From"] = "you@gmail.com"
msg["To"] = "recipient@example.com"
msg["Subject"] = "hello"
msg.set_content("Body goes here.")

with smtplib.SMTP("smtp.gmail.com", 587) as smtp:
smtp.starttls()
smtp.login("you@gmail.com", "abcd efgh ijkl mnop")
smtp.send_message(msg)
Run it. An email leaves your Gmail and shows up in the recipient's inbox a few seconds later, looking exactly like one you typed by hand. That's the whole protocol. Everything else is wrapping that in a workflow.

If port 587 is blocked on your network (corporate Wi-Fi, some hotels), switch to port 465 with smtplib.SMTP_SSL instead of STARTTLS. Same protocol, different transport, one line change.

The pattern for sending to a list

For real outreach you need three files: a .env for the Gmail address and app password, a recipients.csv with name and email columns, and a template.txt where the first line is the subject and the body uses {name} placeholders. The script reads all three, renders an email per recipient, has a dry-run flag that prints everything without sending, asks for a y confirmation if it's a live send, and then sends one at a time with a 4-second delay between each.

The dry-run flag matters more than it sounds. The number one mistake is a typo in your template — {nmae} instead of {name} — and Python's string formatter will quietly send the literal {nmae} to all 80 recipients. A dry-run that prints every rendered email to your terminal catches this in five seconds and saves you the apology email. Always dry-run first.

The whole script is about 120 lines of stdlib Python. I keep the working version saved as an npad here: https://npad.run/p/how-to-send-emails-using-gmail-programmatically-sgkbrkxaxs. If you have Claude Code or Cursor, paste that URL and tell your agent to set this up. It'll write the script, the env, the CSV format, and the template. One shot, no copy-pasting from this article.

Things to know before you live-send

A few things I learned the slightly painful way that aren't obvious from the docs.

Send one email per recipient, not one BCC'd to everyone. BCC blasts look like spam to filters, and some email clients reveal the BCC list anyway, which is how you accidentally show 50 strangers each other's addresses. Sending one at a time means each person sees only their own address and it looks like you actually wrote to them.

Put a real delay between sends. 4–5 seconds is the sweet spot. Faster and Gmail starts returning 421 4.7.0 errors that mean "you look like a bot, slow down." Don't try to be clever about parallelism — Gmail's free tier wants quiet, polite traffic, not a burst of fifty messages in three seconds.

Add a confirmation prompt before sending. "About to send to 80 recipients. Continue? [y/N]" is the cheapest insurance you'll ever write. The day you accidentally point the script at the wrong CSV, that prompt is what saves you.

Limits

Free Gmail will let you send around 500 emails per day before it starts pushing back. Workspace bumps that to 2,000. If you need more than that, you're at the volume where SendGrid or Postmark actually starts to make sense — they exist because at scale you do need bounce handling, deliverability monitoring, and a warmed-up sender reputation. But for under 500 emails a day of personalized outreach, Gmail is genuinely fine. Better than fine actually — it lands in inboxes more reliably than a cold ESP IP because Gmail has spent twenty years building sender trust on its own infrastructure.

btw if you really want to push past the daily cap, you can rotate keys across multiple Gmail accounts. hehe.

If you’re building a dev tool, your best early users are already telling you who they are. They’ve starred a repo adjacent to yours. They care about the problem. They’re not a cold list, they’re a warm one , you just have to do a tiny bit of work to reach them.

The catch is that GitHub hides emails on profiles. But most developers leak theirs anyway, through commits in their own public repos. The author.email field is right there in every commit. That's the seam.

The idea is dumb-simple. Pick a repo whose stargazers are your target audience, pull the stargazer list from the GitHub API, walk each person’s recent repos, read the commit metadata, grab author.email, filter out the noreply@github.com ones, dedupe. No scraping, no sketchy tooling, just the public API and public commit data.

I wrote a bash script that does the whole thing. You need gh (authenticated via gh auth login) and jq. That's it. You run it, paste a repo, set a cap, and a few minutes later you've got a CSV with names, emails, logins, and which repo of theirs you got it from.

./scrape_stargazer_emails.sh

GitHub repo URL or owner/repo: vercel/next.js

Max stargazers to scan [200]: 100

Five minutes later there’s a CSV waiting for you with a hundred real emails of real developers who star projects in your space. The script and the walkthrough are here: https://npad.run/p/how-to-find-emails-of-github-repo-stargazers-hytfnmtgph.

Now the part that actually matters.

This works way better than a Show HN. A launch post gets you two hours of attention from people scrolling past fifty other launches that day. Half of them never even click. But a personal email, written like a human, that mentions something specific from their GitHub, that gets read. Sometimes it gets a reply. Occasionally it gets a user who sticks around and tells their friends.

A few things I’ve learned the slightly harder way. Don’t go wider than 200 stargazers, the returns get noisy fast, more bots, more dead accounts, more noreply emails that slipped through. Don't bulk-send the same template to everyone, because the moment you do that you've turned a warm list into spam, and the recipients can tell. Spend twenty seconds looking at each person's profile and mention their actual repo in the first line. It quadruples replies. Send from a real address with your real name on it, not hello@yourstartup.com. And space the sends out, four or five seconds between each, because Gmail flags bursts and you do not want to land in spam jail on day one.

If you’re shipping a dev tool, this is probably the highest-ROI hour you’ll spend on go-to-market this week. The script is free, the API is free, and the audience is pre-filtered for you. The only hard part is writing the actual email, and you should be writing those one at a time anyway.

Easy way: https://npad.run/p/how-to-find-emails-of-github-repo-stargazers-hytfnmtgph (put this to your claude code, u will get the full working script in one shot, thank me later)

If you’re building a dev tool, your best early users are already telling you who they are. They’ve starred a repo adjacent to yours. They care about the problem. They’re not a cold list, they’re a warm one , you just have to do a tiny bit of work to reach them.

The catch is that GitHub hides emails on profiles. But most developers leak theirs anyway, through commits in their own public repos. The author.email field is right there in every commit. That's the seam.

The idea is dumb-simple. Pick a repo whose stargazers are your target audience, pull the stargazer list from the GitHub API, walk each person’s recent repos, read the commit metadata, grab author.email, filter out the noreply@github.com ones, dedupe. No scraping, no sketchy tooling, just the public API and public commit data.

I wrote a bash script that does the whole thing. You need gh (authenticated via gh auth login) and jq. That's it. You run it, paste a repo, set a cap, and a few minutes later you've got a CSV with names, emails, logins, and which repo of theirs you got it from.

./scrape_stargazer_emails.sh

GitHub repo URL or owner/repo: vercel/next.js

Max stargazers to scan [200]: 100

Five minutes later there’s a CSV waiting for you with a hundred real emails of real developers who star projects in your space. The script and the walkthrough are here: https://npad.run/p/how-to-find-emails-of-github-repo-stargazers-hytfnmtgph.

Now the part that actually matters.

This works way better than a Show HN. A launch post gets you two hours of attention from people scrolling past fifty other launches that day. Half of them never even click. But a personal email, written like a human, that mentions something specific from their GitHub, that gets read. Sometimes it gets a reply. Occasionally it gets a user who sticks around and tells their friends.

A few things I’ve learned the slightly harder way. Don’t go wider than 200 stargazers, the returns get noisy fast, more bots, more dead accounts, more noreply emails that slipped through. Don't bulk-send the same template to everyone, because the moment you do that you've turned a warm list into spam, and the recipients can tell. Spend twenty seconds looking at each person's profile and mention their actual repo in the first line. It quadruples replies. Send from a real address with your real name on it, not hello@yourstartup.com. And space the sends out, four or five seconds between each, because Gmail flags bursts and you do not want to land in spam jail on day one.

If you’re shipping a dev tool, this is probably the highest-ROI hour you’ll spend on go-to-market this week. The script is free, the API is free, and the audience is pre-filtered for you. The only hard part is writing the actual email, and you should be writing those one at a time anyway.

Easy way: https://npad.run/p/how-to-find-emails-of-github-repo-stargazers-hytfnmtgph (put this to your claude code, u will get the full working script in one shot, thank me later)

If you’re building a dev tool, your best early users are already telling you who they are. They’ve starred a repo adjacent to yours. They care about the problem. They’re not a cold list, they’re a warm one , you just have to do a tiny bit of work to reach them.

The catch is that GitHub hides emails on profiles. But most developers leak theirs anyway, through commits in their own public repos. The author.email field is right there in every commit. That's the seam.

The idea is dumb-simple. Pick a repo whose stargazers are your target audience, pull the stargazer list from the GitHub API, walk each person’s recent repos, read the commit metadata, grab author.email, filter out the noreply@github.com ones, dedupe. No scraping, no sketchy tooling, just the public API and public commit data.

I wrote a bash script that does the whole thing. You need gh (authenticated via gh auth login) and jq. That's it. You run it, paste a repo, set a cap, and a few minutes later you've got a CSV with names, emails, logins, and which repo of theirs you got it from.

./scrape_stargazer_emails.sh

GitHub repo URL or owner/repo: vercel/next.js

Max stargazers to scan [200]: 100

Five minutes later there’s a CSV waiting for you with a hundred real emails of real developers who star projects in your space. The script and the walkthrough are here: https://npad.run/p/how-to-find-emails-of-github-repo-stargazers-hytfnmtgph.

Now the part that actually matters.

This works way better than a Show HN. A launch post gets you two hours of attention from people scrolling past fifty other launches that day. Half of them never even click. But a personal email, written like a human, that mentions something specific from their GitHub, that gets read. Sometimes it gets a reply. Occasionally it gets a user who sticks around and tells their friends.

A few things I’ve learned the slightly harder way. Don’t go wider than 200 stargazers, the returns get noisy fast, more bots, more dead accounts, more noreply emails that slipped through. Don't bulk-send the same template to everyone, because the moment you do that you've turned a warm list into spam, and the recipients can tell. Spend twenty seconds looking at each person's profile and mention their actual repo in the first line. It quadruples replies. Send from a real address with your real name on it, not hello@yourstartup.com. And space the sends out, four or five seconds between each, because Gmail flags bursts and you do not want to land in spam jail on day one.

If you’re shipping a dev tool, this is probably the highest-ROI hour you’ll spend on go-to-market this week. The script is free, the API is free, and the audience is pre-filtered for you. The only hard part is writing the actual email, and you should be writing those one at a time anyway.

Easy way: https://npad.run/p/how-to-find-emails-of-github-repo-stargazers-hytfnmtgph (put this to your claude code, u will get the full working script in one shot, thank me later)

​

If your Claude Code quota runs out and you don't want to wait or pay for more, there's a way to keep using the same "claude" command but route it through a free model. It takes about three minutes to set up.

How it works

There's a small open-source proxy called "free-claude-code" that sits on your localhost.

It takes Claude Code's API calls and translates them into a format that NVIDIA's free hosted inference platform (NIM) can serve.

NIM gives you:

- ~5,000 free credits on signup

- 40 requests/minute

That's plenty for steady coding.

The model I use is:

"Kimi-K2" from Moonshot

It's a coding-tuned model that's about 80% as good as Sonnet for normal day-to-day work.

So the flow becomes:

claude command

↓

local proxy

↓

NVIDIA NIM

↓

Kimi-K2

↓

response back into Claude Code UI

Same UI, different model.

---

My setup

I wrapped the whole thing in a shell command called:

claude-free

So I can swap freely between paid and free without touching anything.

Both commands sit on my machine:

- quota out → "claude-free"

- quota back → "claude"

They don't share env vars and my real config is untouched.

---

What you need

You need an NVIDIA NIM API key.

This is the only part you can't automate.

Go here:

build.nvidia.com/settings/api-keys

- sign in with Google or GitHub

- click "Generate API Key"

- copy the "nvapi-..." string

Takes a minute.

You also need:

- git

- node (for Claude Code itself)

- uv for Python

If you don't have uv:

curl -LsSf https://astral.sh/uv/install.sh | sh

---

Setup

Clone the proxy somewhere persistent.

Do NOT use "/tmp" because it gets wiped on reboot.

git clone --depth 1 https://github.com/Alishahryar1/free-claude-code.git ~/.local/share/claude-free

cd ~/.local/share/claude-free

uv python install 3.14

uv sync

Write a ".env" file in the same directory:

NVIDIA_NIM_API_KEY=nvapi-your-key-here

MODEL=nvidia_nim/moonshotai/kimi-k2-instruct

ANTHROPIC_AUTH_TOKEN=freecc

---

Important

Do NOT use the model the README ships with.

The default is:

z-ai/glm4.7

It hangs forever and never returns.

I tried a few others too:

- "deepseek-v4-pro"

- "qwen3-coder-480b"

Both unreachable.

The two that actually work on the free tier are:

- "moonshotai/kimi-k2-instruct" ← best for coding

- "meta/llama-3.3-70b-instruct" ← decent backup

---

About "ANTHROPIC_AUTH_TOKEN"

ANTHROPIC_AUTH_TOKEN=freecc

This is just a local password between the wrapper and the proxy.

The proxy rejects requests without it.

It never leaves your machine.

You can set it to anything — just keep the wrapper and ".env" in sync.

---

Wrapper script

Save this as:

~/.local/bin/claude-free

#!/usr/bin/env bash

set -e

PROXY_DIR="$HOME/.local/share/claude-free"

PORT=8082

if ! curl -s -m 1 "http://127.0.0.1:$PORT/v1/models" -H "x-api-key: freecc" >/dev/null 2>&1; then

echo "claude-free: starting proxy on :$PORT..." >&2

cd "$PROXY_DIR"

nohup uv run uvicorn server:app \

--host 127.0.0.1 \

--port "$PORT" \

>> "$PROXY_DIR/proxy.log" 2>&1 &

for i in {1..30}; do

curl -s -m 1 "http://127.0.0.1:$PORT/v1/models" \

-H "x-api-key: freecc" >/dev/null 2>&1 && break

sleep 0.5

done

fi

export ANTHROPIC_AUTH_TOKEN=freecc

export ANTHROPIC_BASE_URL="http://127.0.0.1:$PORT"

export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1

exec claude "$@"

Make it executable:

chmod +x ~/.local/bin/claude-free

Make sure "~/.local/bin" is on your PATH:

echo $PATH | grep -q "$HOME/.local/bin" && echo ok || echo "add to .zshrc"

Open a new terminal.

Run:

claude-free

You're now running Claude Code on a free model.

---

Verifying it works

If you want to confirm it's actually routing through the proxy and not silently hitting Anthropic:

Kill the proxy and run "claude-free" again.

The wrapper should restart it automatically.

You can also tail the logs:

tail -f ~/.local/share/claude-free/proxy.log

and watch requests come through.

---

One thing that confused me

Claude Code UI may still show your old account/model name in the header:

Sonnet 4.6

or whatever you used before.

That label is cached locally.

The model actually serving you is Kimi.

Trust the logs, not the UI.

---

The faster way

I saved this whole setup as a single npad note:

https://npad.run/p/free-claude-code-in-3-minutes-claude-free-wrapper-nvidia-nim-fbh3d9p443

Paste that URL into Claude Code and say:

«"do this, ask me when you need the NVIDIA key"»

Your agent:

- reads the note

- runs every command

- pauses at the human-only step

- continues automatically

- tests the install

One shot.

You'll also save tokens because the agent won't repeat the same mistakes mine did.

---

Caveats

"Kimi-K2" is not Opus.

It's good at coding and decent at tool use, but you'll feel the difference on:

- hard reasoning

- long-context tasks

Use this when:

- your real quota is out

- casual coding

- side projects

For work that matters, pay for real Claude.

---

Free tier limits

NVIDIA free tier currently gives roughly:

- 40 requests/minute

- ~5,000 free credits on signup

Budget refresh schedule is unclear.

A single Claude Code turn is usually:

5–15 requests

So the rate limit mostly matters during large multi-file refactors.

btw u can rotate keys hehe

---

Security note

The proxy is open source and runs on localhost.

But technically every prompt passes through it on the way to NVIDIA.

Don't run this on a shared machine.

---

Uninstall

Two lines:

pkill -f "uvicorn server:app"

rm -rf ~/.local/share/claude-free ~/.local/bin/claude-free

Nothing left behind.

Your real Claude setup stays untouched.