DEV Community: masato

Copy-Paste Ready: Auto-Export GA4 + Search Console Data with TypeScript

masato — Thu, 09 Apr 2026 17:02:33 +0000

Still manually exporting CSVs from GA4 and Search Console?

TL;DR: Two TypeScript files + GitHub Actions = fully automated weekly data export. Service Account setup takes 15 minutes, code is copy-paste ready.

Architecture

GitHub Actions (weekly cron)
  ├── search_console_tracker.ts → search-console-latest.csv
  └── ga4_tracker.ts            → ga4-pages-latest.csv
                                  ga4-acquisition-latest.csv

Prerequisites (15 min one-time setup)

Create a Google Cloud project
Enable Search Console API + Google Analytics Data API
Create a Service Account → download JSON key
Add the Service Account to Search Console ("Restricted") and GA4 ("Viewer")

Search Console Tracker

import { google } from "googleapis";
import { writeFileSync, mkdirSync, existsSync } from "fs";

const SERVICE_ACCOUNT_JSON = process.env.GOOGLE_SERVICE_ACCOUNT_JSON ?? "";
const SITE_URL = process.env.SEARCH_CONSOLE_SITE_URL ?? "";
const OUTPUT_DIR = process.env.ANALYTICS_OUTPUT_DIR || "./analytics";

function getClient() {
  const credentials = JSON.parse(SERVICE_ACCOUNT_JSON);
  const auth = new google.auth.GoogleAuth({
    credentials,
    scopes: ["https://www.googleapis.com/auth/webmasters.readonly"],
  });
  return google.searchconsole({ version: "v1", auth });
}

async function main() {
  const client = getClient();
  const now = new Date();
  const endDate = new Date(now.getTime() - 3 * 86400000); // 3 days ago (data lag)
  const startDate = new Date(endDate.getTime() - 28 * 86400000);
  const fmt = (d: Date) => d.toISOString().split("T")[0];

  const res = await client.searchanalytics.query({
    siteUrl: SITE_URL,
    requestBody: {
      startDate: fmt(startDate),
      endDate: fmt(endDate),
      dimensions: ["query"],
      rowLimit: 500,
    },
  });

  const rows = res.data.rows ?? [];
  if (!existsSync(OUTPUT_DIR)) mkdirSync(OUTPUT_DIR, { recursive: true });

  const csv = [
    "Query,Clicks,Impressions,CTR,Position",
    ...rows.map((r) =>
      `"${(r.keys?.[0] ?? "").replace(/"/g, '""')}",${r.clicks},${r.impressions},${((r.ctr ?? 0) * 100).toFixed(2)}%,${(r.position ?? 0).toFixed(1)}`
    ),
  ].join("\n");

  writeFileSync(`${OUTPUT_DIR}/search-console-latest.csv`, csv, "utf-8");
  console.log(`Saved ${rows.length} queries`);
}

main();

GA4 Tracker

import { google } from "googleapis";
import { writeFileSync, mkdirSync, existsSync } from "fs";

const SERVICE_ACCOUNT_JSON = process.env.GOOGLE_SERVICE_ACCOUNT_JSON ?? "";
const PROPERTY_ID = process.env.GA4_PROPERTY_ID ?? "";
const OUTPUT_DIR = process.env.ANALYTICS_OUTPUT_DIR || "./analytics";

function getClient() {
  const credentials = JSON.parse(SERVICE_ACCOUNT_JSON);
  const auth = new google.auth.GoogleAuth({
    credentials,
    scopes: ["https://www.googleapis.com/auth/analytics.readonly"],
  });
  return google.analyticsdata({ version: "v1beta", auth });
}

async function main() {
  const client = getClient();
  if (!existsSync(OUTPUT_DIR)) mkdirSync(OUTPUT_DIR, { recursive: true });

  const res = await client.properties.runReport({
    property: `properties/${PROPERTY_ID}`,
    requestBody: {
      dateRanges: [{ startDate: "28daysAgo", endDate: "yesterday" }],
      dimensions: [{ name: "pagePath" }],
      metrics: [
        { name: "screenPageViews" },
        { name: "averageSessionDuration" },
        { name: "bounceRate" },
      ],
      orderBys: [{ metric: { metricName: "screenPageViews" }, desc: true }],
      limit: 100,
    },
  });

  const rows = res.data.rows ?? [];
  const csv = [
    "Page path,Views,Avg engagement time (sec),Bounce rate",
    ...rows.map((r) => {
      const path = r.dimensionValues?.[0]?.value ?? "";
      const views = r.metricValues?.[0]?.value ?? "0";
      const time = parseFloat(r.metricValues?.[1]?.value ?? "0").toFixed(1);
      const bounce = (parseFloat(r.metricValues?.[2]?.value ?? "0") * 100).toFixed(1);
      return `"${path}",${views},${time},${bounce}%`;
    }),
  ].join("\n");

  writeFileSync(`${OUTPUT_DIR}/ga4-pages-latest.csv`, csv, "utf-8");
  console.log(`Pages: ${rows.length} rows`);
}

main();

GitHub Actions

name: Analytics Tracker
on:
  schedule:
    - cron: '0 1 * * 1'  # Every Monday
  workflow_dispatch:
permissions:
  contents: write
jobs:
  track:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm ci || npm install
      - run: mkdir -p analytics-output
      - name: Search Console
        env:
          GOOGLE_SERVICE_ACCOUNT_JSON: ${{ secrets.GOOGLE_SERVICE_ACCOUNT_JSON }}
          SEARCH_CONSOLE_SITE_URL: https://your-site.com
          ANALYTICS_OUTPUT_DIR: ./analytics-output
        run: npx tsx search_console_tracker.ts
      - name: GA4
        env:
          GOOGLE_SERVICE_ACCOUNT_JSON: ${{ secrets.GOOGLE_SERVICE_ACCOUNT_JSON }}
          GA4_PROPERTY_ID: ${{ secrets.GA4_PROPERTY_ID }}
          ANALYTICS_OUTPUT_DIR: ./analytics-output
        run: npx tsx ga4_tracker.ts
      - run: |
          git config user.name "bot"
          git config user.email "bot@example.com"
          git add analytics-output/*.csv
          git diff --cached --quiet || git commit -m "data: update analytics"
          git push

Dependencies

npm install googleapis tsx

Bonus: Feed It to AI

Once CSVs auto-update, you can ask Claude Code:

"Read search-console-latest.csv and list keywords with high clicks but ranking below position 10."

"Find pages with high PV but low engagement time."

Automated data + AI analysis = SEO on autopilot.

Summary

Step	Time
Service Account setup	15 min (one-time)
Copy-paste code	2 min
GitHub Actions runs weekly	0 min

No more manual exports.

I Almost Leaked Session Cookies to GitHub — Here's How I Made It Impossible

masato — Thu, 09 Apr 2026 17:02:24 +0000

Have you ever pushed to GitHub and thought, "Wait, did I just commit something sensitive?"

TL;DR: .gitignore alone won't save you. A pre-commit hook that scans for secret patterns will physically prevent accidental leaks. Setup takes 3 minutes.

What Happened

I run 11 AI agents for automated SNS operations. One agent saved browser session cookies to a JSON file for auto-posting to a blogging platform:

{
  "cookies": [
    {
      "name": "_session_v5",
      "value": "626f63e8bc9a23c20a455bb4...",
      "httpOnly": true,
      "secure": true
    }
  ]
}

This file wasn't in .gitignore. I caught it in git status right before pushing.

Why .gitignore Isn't Enough

.gitignore only blocks files you already know about. It can't protect against:

Credentials generated by tools at runtime
Downloaded Service Account JSON keys
Auth state files created by automation scripts

The Fix: Pre-commit Hook

Save this as .git/hooks/pre-commit:

#!/bin/bash
BLOCKED=0
FILES=$(git diff --cached --name-only --diff-filter=ACM)

if [ -z "$FILES" ]; then exit 0; fi

# Dangerous filename patterns
for FILE in $FILES; do
  if echo "$FILE" | grep -qE "\.pem$|\.key$|\.p12$|credentials\.json|service.account.*\.json|client_secret.*\.json|token\.json|state\.json|_cookies\.json|\.env$|\.env\."; then
    echo "BLOCKED: $FILE (dangerous filename)"
    BLOCKED=1
  fi
done

# Secret content patterns
for FILE in $FILES; do
  if [ ! -f "$FILE" ]; then continue; fi
  if file "$FILE" 2>/dev/null | grep -q "binary"; then continue; fi
  if git diff --cached -- "$FILE" | grep -qE "PRIVATE KEY|BEGIN.*KEY|sk_live_|sk_test_|ghp_[a-zA-Z0-9]{36}|\"type\":.*\"service_account\""; then
    echo "BLOCKED: $FILE contains secret pattern"
    BLOCKED=1
  fi
done

if [ $BLOCKED -ne 0 ]; then
  echo "Commit blocked. Potential secrets detected."
  echo "To override: git commit --no-verify"
  exit 1
fi
exit 0

chmod +x .git/hooks/pre-commit

Test It

echo 'sk_live_fake1234567890abcdef' > test-leak.txt
git add test-leak.txt
git commit -m "test"
# → BLOCKED: test-leak.txt contains secret pattern

Commit is rejected. Crisis averted.

Also: Harden Your .gitignore

*.pem
*.key
*.p12
*-credentials.json
service-account*.json
client_secret*.json
token.json
credentials.json
.env
.env.*
*_cookies.json

Summary

Layer	What it does	Setup time
.gitignore	Blocks known patterns	1 min
Pre-commit hook	Detects unknown patterns, blocks commit	2 min
Total	Two-layer protection	3 min

7 Stripe Monetization Patterns for Indie SaaS (and How to Combine Them)

masato — Tue, 31 Mar 2026 09:51:20 +0000

There's plenty of content on "how to implement Stripe subscriptions." What's harder to find is a clear breakdown of which model to choose and how to combine multiple models as your product grows.

This post covers all 7 monetization patterns available in Stripe, plus 6 combination strategies that work well for indie SaaS products.

Why decide on your monetization model before you write code

If you don't nail down your billing model early, you'll hit expensive refactors later. In Stripe, each pricing model maps to a different Product/Price structure. Adding a metered billing tier on top of an existing subscription requires schema changes, new webhook handlers, and a pricing page redesign.

Decide upfront. It saves you a painful afternoon six months from now.

The 7 Stripe-compatible monetization models

1. Monthly Subscription

The default for most SaaS products. Reliable, predictable, and what most users expect.

Use Stripe's Subscription object
Most starter kits (like those built on Next.js + Stripe) support this out of the box
Best for: Any SaaS with habitual, recurring usage

const price = await stripe.prices.create({
  unit_amount: 1900, // $19.00
  currency: 'usd',
  recurring: { interval: 'month' },
  product: 'prod_xxxx',
});

2. One-time Payment (Lifetime Deal)

Single payment, lifetime access. Works particularly well with AppSumo launches.

Great for generating upfront cash before subscriptions kick in
No churn, but no recurring revenue — plan accordingly
Best for: Tools, templates, and launch campaigns

3. Usage-based / Metered Billing

Charge based on what's consumed — API calls, audio minutes, AI generations, etc.

Use Stripe's Metered Billing
Low-usage customers pay less; heavy users pay more
Best for: AI-powered products, API services

await stripe.subscriptionItems.createUsageRecord(
  'si_xxxx',
  { quantity: 1, action: 'increment' }
);

4. Freemium

Free tier + paid upgrade. Widens the top of the funnel.

The free tier's limits matter more than the paid tier's features
Aim to make users feel "I need just a little more" — not "this is too restricted to bother"
Best for: Viral B2C tools, developer tools with network effects

5. Per-seat Pricing

Charge based on the number of users or team members.

Revenue scales with the team, which is predictable
Update Stripe's quantity dynamically as seats are added/removed
Best for: B2B team collaboration tools

6. Affiliate / Referral Program

Share a percentage of revenue with people who refer new customers.

Stripe Connect (Express) automates payouts — but it requires approval
For early stage: manual payouts via bank transfer work fine
Particularly powerful for products that spread through in-person communities
Best for: Local business tools, SMB software, products where word-of-mouth dominates

7. Annual Billing Discount

Offer a discount (typically 15–20%) for paying upfront annually. Works alongside any other model.

Customer gets a discount; you get better cash flow
$19/month → $190/year (≈ 2 months free) is a standard structure
Best for: Add to any subscription product once it's stable

6 combination strategies

Pattern A: Freemium + Monthly + Annual

The classic SaaS growth stack.

Best for: Developer tools, AI tools
Revenue example: 100 signups → 20 paying users → $380 MRR at $19/month

Pattern B: Monthly + Affiliate

Subscription revenue with referrers earning a recurring cut of what they bring in.

The key insight: referrers who earn a recurring % are incentivized to keep their customers from churning, not just close the deal.
Best for: SMB tools, products that spread through professional communities

Pattern C: Metered + Monthly cap

Usage-based billing with a ceiling that converts to flat-rate.

Removes the anxiety of unpredictable bills. Automatically suggest the flat plan when it becomes cheaper.
Best for: AI-powered B2C tools, API services

Pattern D: Lifetime Deal → Monthly only

Launch with AppSumo or ProductHunt for upfront cash, then switch to subscriptions-only.

Warning: Don't let too many LTD users accumulate or the server cost becomes unmanageable. Set a hard cap on units and a deadline.
Best for: English-language SaaS targeting AppSumo audience

Pattern E: Monthly + Upsell (Add-ons)

Core features on a flat subscription, optional features sold separately.

Add-ons sold to existing users have zero customer acquisition cost — pure LTV improvement.
Best for: B2B SaaS with a range of advanced features

Pattern F: Freemium + Metered + Affiliate (Growth Loop)

The full viral loop: free entry, usage-based monetization, referrals to fuel growth.

This is the Dropbox model. It's the most powerful combination but also the most complex to implement. Don't start here — add components one at a time once you have traction.
Best for: B2C products with strong network effects (growth phase, not launch)

Start simple, layer in complexity

At 0→1 stage, monthly subscription is enough. Every layer of complexity adds implementation cost, explanation cost, and user confusion.

A sane rollout order:

Month 1: Monthly subscription with freemium tier
Month 3: Add annual billing (cash flow win)
Launch: Add lifetime deal for AppSumo campaign
Growth phase: Add affiliate program once you have happy users to activate

Wrapping up

Stripe supports more monetization models than most indie developers use. The goal isn't to implement all of them — it's to pick the right combination for your product type and stage.

Start with one model. Nail it. Then layer.

Building a SaaS from scratch? LaunchKit is a Next.js + Supabase + Stripe starter kit that ships with auth, database, and payments pre-configured — so you can skip setup and start building the actual product.

DEV Community: masato

Copy-Paste Ready: Auto-Export GA4 + Search Console Data with TypeScript

Still manually exporting CSVs from GA4 and Search Console?

Architecture

Prerequisites (15 min one-time setup)

Search Console Tracker

GA4 Tracker

GitHub Actions

Dependencies

Bonus: Feed It to AI

Summary

Related Links

I Almost Leaked Session Cookies to GitHub — Here's How I Made It Impossible

Have you ever pushed to GitHub and thought, "Wait, did I just commit something sensitive?"

What Happened

Why .gitignore Isn't Enough

The Fix: Pre-commit Hook

Test It

Also: Harden Your .gitignore

Summary

Related Links

7 Stripe Monetization Patterns for Indie SaaS (and How to Combine Them)

Why decide on your monetization model before you write code

The 7 Stripe-compatible monetization models

1. Monthly Subscription

2. One-time Payment (Lifetime Deal)

3. Usage-based / Metered Billing

4. Freemium

5. Per-seat Pricing

6. Affiliate / Referral Program

7. Annual Billing Discount

6 combination strategies

Pattern A: Freemium + Monthly + Annual

Pattern B: Monthly + Affiliate

Pattern C: Metered + Monthly cap

Pattern D: Lifetime Deal → Monthly only

Pattern E: Monthly + Upsell (Add-ons)

Pattern F: Freemium + Metered + Affiliate (Growth Loop)

Start simple, layer in complexity

Wrapping up