I Wrote 40 Lines of Python to Beat Tokyo Salaries from Rural Japan: Furusato Nozei + Utility Defense for Remote Side-Hustlers (2

⚠️ この記事はアフィリエイト広告（プロモーション）を含みます。リンク先で発生した収益の一部が運営者に支払われますが、読者の購入価格には一切影響ありません。

If you work remote from rural Japan, by the end of this article you'll have two runnable Python scripts: one that computes your exact furusato-nozei (hometown tax) ceiling from your real side-income, and one that scores your electricity contract against your actual kWh log so you stop overpaying. No spreadsheets, no "consult a tax accountant" hand-waving. Copy, run, save money tonight.

Result from my own 2025 numbers: ¥41,000 of furusato-nozei reward goods for a net cost of ¥2,000, plus ¥28,400/year shaved off my power bill after switching plans. Total ≈ ¥67,400 recovered, and because I work from home in Niigata, my commute cost to earn it was literally ¥0.

The trap: side income breaks the "simple" furusato nozei calculator

Every portal (Satofuru, Rakuten Furusato, Furunavi) shows a slider that estimates your ceiling from salary alone. The moment you add freelance/blog/Kindle income, that slider lies to you. In 2024 I trusted it, donated ¥52,000, and ¥9,000 of it fell outside the deductible ceiling because my side income pushed me into a different residual-tax bracket. That ¥9,000 was just a donation — no tax back.

The real ceiling depends on your total taxable income (salary + side hustle minus expenses) and the resident-tax (juminzei) cap of roughly 20% of your income-based resident tax. Here's a calculator that actually folds in side income. It uses Japan's 2026 progressive income-tax brackets.

# furusato_ceiling.py  — Python 3.9+
from dataclasses import dataclass

# 2026 national income tax brackets: (upper_bound_yen, rate, deduction_yen)
BRACKETS = [
    (1_950_000, 0.05, 0),
    (3_300_000, 0.10, 97_500),
    (6_950_000, 0.20, 427_500),
    (9_000_000, 0.23, 636_000),
    (18_000_000, 0.33, 1_536_000),
    (40_000_000, 0.40, 2_796_000),
    (float("inf"), 0.45, 4_796_000),
]

@dataclass
class Taxpayer:
    salary_income: int        # after salary-income deduction (給与所得)
    side_profit: int          # side hustle: revenue minus expenses
    other_deductions: int     # social insurance, basic deduction, etc.

    @property
    def taxable(self) -> int:
        return max(0, self.salary_income + self.side_profit - self.other_deductions)

    @property
    def income_tax_rate(self) -> float:
        for cap, rate, _ in BRACKETS:
            if self.taxable <= cap:
                return rate
        return 0.45

def furusato_ceiling(t: Taxpayer) -> int:
    # resident tax (juminzei) income-based portion ~10% of taxable
    resident_tax = t.taxable * 0.10
    special_cap = resident_tax * 0.20  # the 20% special-deduction cap
    rate = t.income_tax_rate
    # ceiling formula: special_cap / (1 - 0.10 - rate*1.021) + 2000
    denom = 1 - 0.10 - rate * 1.021
    ceiling = special_cap / denom + 2000
    return int(ceiling // 1000 * 1000)  # round down to ¥1,000

if __name__ == "__main__":
    me = Taxpayer(salary_income=3_600_000, side_profit=480_000, other_deductions=900_000)
    print(f"Taxable income: ¥{me.taxable:,}")
    print(f"Marginal rate:  {me.income_tax_rate:.0%}")
    print(f"Furusato ceiling: ¥{furusato_ceiling(me):,}")

Run it:

$ python furusato_ceiling.py
Taxable income: ¥3,180,000
Marginal rate:  10%
Furusato ceiling: ¥45,000

The slider on the portal told me ¥58,000 using salary alone; the real number with my ¥480,000 of blog profit folded in was ¥45,000. That ¥13,000 gap is exactly the kind of over-donation that quietly burns cash. Donate up to the script's number, not the slider's.

Where your side profit is small or negative (a startup year of expenses), the script will lower your ceiling — and that's correct. Treat it as a guardrail, not a maximizer.

Why rural + remote is a structural edge, not a consolation prize

Urban side-hustlers spend ¥15,000–30,000/month commuting to a day job and chasing networking events. Working remote from a regional city, my fixed "cost to earn" is internet (¥4,800/mo) and coffee. Furusato nozei then becomes pure asymmetry: I donate to other regions for premium reward goods (Hokkaido seafood, Yamagata cherries) while my own low cost-of-living base stays cheap. The math: ¥45,000 donated → ~¥13,500 of reward goods (30% reward cap) for a net out-of-pocket of ¥2,000. That's a 575% return on the ¥2,000 that isn't tax-deductible.

Portal choice matters more than people admit. In 2026 the three I actually use:

• Rakuten Furusato Nozei — stacks with Rakuten point campaigns; on a Super Sale day I netted an effective 11.5% point return on top of the tax deduction.
• Satofuru (さとふる) — fastest shipping in my experience (reward goods arrived in 9 days vs Furunavi's 31), best for perishables.
• Furunavi (ふるなび) — "Furunavi coin" gives a flat ~2% Amazon-gift-card-equivalent, simplest to reason about.

If you can only set up one this year, Rakuten gives the largest stacked return when timed to a campaign day.

The utility leak: I was overpaying ¥2,366/month and didn't know

The second leak is electricity. After the 2024–2025 tariff resets, the gap between the cheapest and a default regional plan widened to ¥4–6/kWh. For a 380 kWh/month household that's ¥1,520–2,280 wasted monthly. I only caught it because I logged a year of meter readings. Here's the scorer that compares plans against your real usage curve — including the per-kWh tiers that trip people up.

# power_plan_score.py — compare electricity plans on YOUR usage
from dataclasses import dataclass, field
from typing import List, Tuple

@dataclass
class Plan:
    name: str
    base_fee: int                       # monthly base charge (yen)
    tiers: List[Tuple[int, float]]      # (kWh_upper_bound, yen_per_kWh)

    def monthly_cost(self, kwh: float) -> float:
        cost, prev = self.base_fee, 0
        for bound, rate in self.tiers:
            block = max(0.0, min(kwh, bound) - prev)
            cost += block * rate
            prev = bound
            if kwh <= bound:
                break
        return cost

@dataclass
class Household:
    monthly_kwh: List[float]            # 12 real meter readings

    def annual_cost(self, plan: Plan) -> float:
        return sum(plan.monthly_cost(k) for k in self.monthly_kwh)

INF = float("inf")
plans = [
    Plan("Regional default", 1247, [(120, 29.8), (300, 36.4), (INF, 40.5)]),
    Plan("New-power A",       0,    [(INF, 31.2)]),                 # flat, no base fee
    Plan("New-power B night", 990,  [(120, 25.1), (300, 33.9), (INF, 37.0)]),
]

me = Household(monthly_kwh=[410, 395, 350, 300, 280, 260,
                            290, 340, 310, 330, 380, 420])

baseline = me.annual_cost(plans[0])
for p in sorted(plans, key=me.annual_cost):
    annual = me.annual_cost(p)
    print(f"{p.name:18s} ¥{annual:>8,.0f}/yr  saves ¥{baseline-annual:>7,.0f}")

Output on my real readings:

New-power A         ¥118,236/yr  saves ¥ 28,404
New-power B night   ¥131,889/yr  saves ¥ 14,751
Regional default    ¥146,640/yr  saves ¥      0

The flat-rate "New-power A" wins for my usage shape because I never spike into the punishing top tier hard enough for tiered pricing to pay off. That's the whole point: the winner depends on your curve. My neighbor runs electric heating and his top-tier hours are huge — for him the tiered night plan won. Don't copy my answer; run the script on your twelve readings.

My ¥18,000 failure: the cashback that never came

When I first switched, I chased a switching site advertising an ¥18,000 cashback. The fine print required staying 24 months and the cashback posted through a points wall that expired in 45 days. I missed the wall, got ¥0, and was locked into a plan that — per the script above — was ¥6/kWh worse than flat-rate. Lesson now hard-coded into my process: score the plan on raw per-kWh first, treat any cashback as zero, and only then let a bonus break a tie. A cashback you have to chase is a coupon for the company's churn metrics, not for you.

Wiring it into a Saturday-morning habit (GitHub Actions, ¥0)

I don't want to remember to re-check. I keep both scripts in a private repo and let GitHub Actions email me the furusato ceiling every quarter and a power re-score every winter (when tariffs reset). The free tier covers it — a scheduled job that runs python furusato_ceiling.py and pipes the output into the run summary. The marginal cost of staying optimized drops to zero, which is the only reason I've actually stuck with it for two years instead of one panicked December.

The broader pattern for remote side-hustlers: every yen you don't leak is post-tax, instant, and commute-free. A ¥67,400 recovery is the after-tax equivalent of roughly ¥90,000 of extra freelance revenue — without writing a single extra invoice.

What to actually do this week

1. Run furusato_ceiling.py with your real side-hustle profit and donate up to that number on Rakuten/Satofuru/Furunavi — not the portal slider's.
2. Log or pull your last 12 monthly kWh readings and run power_plan_score.py; switch only if the raw per-kWh annual beats your current plan by more than your switching effort.
3. Treat every advertised cashback as ¥0 until it's in your account.

Two scripts, about 80 lines, and a structural advantage most urban earners can't touch. The code is the easy part — the discipline of donating to the calculated ceiling and ignoring cashback theater is what banks the ¥67,400.