<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>RI electricity rates compared — honest, source-labeled | RI Rate Check</title>
<meta name="description" content="Rhode Island electricity rates compared honestly: every supplier offer checked against the 17.029¢ Last Resort rate, with teaser flags, RI DPUC track records, municipal aggregation checks, and winter bill credits shown separately.">
<link rel="stylesheet" href="styles.css">
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the Last Resort rate?",
      "acceptedAnswer": { "@type": "Answer", "text": "The Last Resort rate (Last Resort Service) is Rhode Island Energy's default supply rate — what you pay for the supply part of your bill if you have not chosen a third-party supplier or been auto-enrolled in a municipal aggregation program. For October 1, 2026 through March 31, 2027 it is 17.029 cents per kWh, approved by the RI Public Utilities Commission. It resets every April 1 and October 1; the summer 2026 rate was 11.092 cents per kWh." }
    },
    {
      "@type": "Question",
      "name": "Is switching electricity suppliers worth it in Rhode Island?",
      "acceptedAnswer": { "@type": "Answer", "text": "Sometimes — but often not. An analysis of RI Division of Public Utilities data found that between 2017 and 2024, third-party supply customers paid $61.6 million more in total than they would have on default service. Switching only makes sense when the rate clearly beats the Last Resort rate after fees, the term spans the expensive winter season, and the supplier's Rhode Island track record is clean. Staying put is a valid answer, and this site says so when the math says so." }
    },
    {
      "@type": "Question",
      "name": "What is municipal aggregation?",
      "acceptedAnswer": { "@type": "Answer", "text": "Municipal aggregation (community electricity) is when a city or town buys electricity supply in bulk for its residents. Eligible households are auto-enrolled, and anyone can leave or change tiers at any time with no fee. In Rhode Island, eight municipalities run programs with Good Energy and NextEra Energy Services: Barrington, Central Falls, Narragansett, Newport, North Kingstown, Portsmouth, Providence, and South Kingstown. Their winter 2026-27 Standard rate is 16.929 cents per kWh." }
    },
    {
      "@type": "Question",
      "name": "Do electricity supplier contracts auto-renew in Rhode Island?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. Rhode Island law prohibits residential electricity supplier contracts from auto-renewing. When your term ends, the contract ends — you choose a new offer or return to the default Last Resort service. Always check what happens at the end of a term before signing, because a supplier may offer you a new rate rather than renewing the old one." }
    },
    {
      "@type": "Question",
      "name": "What is the maximum early-termination fee in Rhode Island?",
      "acceptedAnswer": { "@type": "Answer", "text": "By Rhode Island law, an early-termination fee on a residential electricity supply contract is capped at $50 — or twice your average monthly bill, if that is less (R.I. Gen. Laws § 39-26.7-6(a); Division rule 815-RICR-30-05-2 § 2.6). Many plans charge $0; this site shows each plan's fee when it is confirmed, and marks it 'not confirmed' when it is not." }
    },
    {
      "@type": "Question",
      "name": "Do I lose the state winter credits if I switch suppliers?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. Both state credits are fixed-dollar line items on the delivery side of your Rhode Island Energy bill, and neither is tied to who supplies your electricity. The Hold Harmless credit is $14.50/month on bills rendered October 2026 through September 2027 (Tariff R.I.P.U.C. No. 2304). The RGGI emergency credit is $20.45/month in each of the January, February and March 2027 billing periods, for distribution accounts in rate classes A-16 and A-60 — the standard and low-income residential classes (Tariff R.I.P.U.C. No. 2309). Because the credits follow your distribution account, third-party supplier customers and municipal aggregation customers keep both." }
    }
  ]
}
</script>
</head>
<body>
<div class="wrap">

  <header class="masthead">
    <pre class="logo" aria-hidden="true">+==============================================+
|  RI_RATE_CHECK  v1.0  //  PROVIDENCE, RI     |
+==============================================+</pre>
    <p class="tagline">RHODE ISLAND ELECTRICITY RATES, COMPARED HONESTLY.<br>
    NO SPONSORED RANKINGS. NO TEASER GAMES. <span class="prompt">&gt;</span><span class="cursor" aria-hidden="true"></span></p>
    <nav class="nav" aria-label="Sections">
      <a href="#compare">[ COMPARE ]</a>
      <a href="#towns">[ YOUR TOWN ]</a>
      <a href="#credits">[ WINTER CREDITS ]</a>
      <a href="#promise">[ OUR PROMISE ]</a>
      <a href="#faq">[ FAQ ]</a>
      <a href="methodology.html">[ METHODOLOGY ]</a>
      <a href="affiliate-disclosure.html">[ DISCLOSURE ]</a>
      <a href="terms.html">[ TERMS ]</a>
      <a href="privacy.html">[ PRIVACY ]</a>
    </nav>
  </header>

  <main>
    <!-- ============ HERO ============ -->
    <section class="frame hero" aria-labelledby="hero-h">
      <h1 id="hero-h">Still on Rhode Island Energy&rsquo;s default rate?</h1>
      <p class="big">Then you are paying the <strong>Last Resort rate: 17.029&cent;/kWh</strong> this winter.
      Below: the supplier offers for Rhode Island that we found and could source, ranked by estimated cost —
      with short-term and renewal risks labeled, and each supplier&rsquo;s Rhode Island track record attached where our data has one.
      Sometimes the honest answer is <strong>stay put</strong>. We will tell you when it is.</p>

      <div class="controls">
        <div class="field">
          <label for="zip">YOUR ZIP CODE</label>
          <input id="zip" type="text" inputmode="numeric" autocomplete="postal-code" value="02911" maxlength="5" aria-describedby="zip-note">
        </div>
        <div class="field">
          <label for="kwh">YOUR MONTHLY USE (kWh)</label>
          <div class="kwh-row">
            <input id="kwh" type="number" inputmode="numeric" min="50" max="5000" step="10" value="600">
            <input id="kwh-range" type="range" min="100" max="2000" step="50" value="600" aria-label="Monthly use slider">
          </div>
        </div>
      </div>
      <p id="zip-note" class="note">ZIP-level quotes are not live yet: supplier sites hide their real RI quotes behind ZIP gates.
      Every rate below is labeled with exactly how well it is verified — <span class="b-inline ok">VERIFIED</span> or
      <span class="b-inline warn">ADVERTISED — NOT YET ZIP-VERIFIED</span> — and nothing here is presented as a quote.
      Not sure of your usage? A typical RI household uses about 550 kWh/month.</p>
    </section>

    <!-- ============ BENCHMARK + YOUR NUMBERS ============ -->
    <section class="frame" aria-labelledby="bench-h">
      <h2 id="bench-h">== THE RATE TO BEAT ==</h2>
      <div id="benchmark-card"><!-- rendered from data/supplier_offers.json --></div>
      <h3 class="subhead">&gt; YOUR NUMBERS</h3>
      <div id="summary" class="readout" aria-live="polite"><!-- rendered by app.js --></div>
      <p class="note">Supply charges only. Delivery charges on your bill do not change when you switch suppliers,
      so they are not part of this comparison. Savings figures compare supply charges only; the state bill credits
      are shown as their own line (see <a href="#credits">WINTER CREDITS</a>) because they are identical for every
      household — confirmed for default, supplier, and aggregation customers alike.</p>
    </section>

    <!-- ============ OFFERS ============ -->
    <section class="frame" id="compare" aria-labelledby="offers-h">
      <h2 id="offers-h">== RHODE ISLAND ELECTRICITY RATES: THE OFFERS ==</h2>
      <p>Ranked by estimated winter supply cost at your usage. <strong>Suppliers with poor Rhode Island track
      records are listed after cleaner offers no matter how cheap the headline rate looks</strong> — that is the
      honest ranking, and it is deliberate. A flagged offer never gets a &ldquo;top pick&rdquo; badge here.
      The <strong>&#9733; TOP HONEST PICK</strong> badge is mechanical: an offer earns it only if it has a clean
      track record in the sourced data, a confirmed $0 early-termination fee, a confirmed term, a fixed rate,
      and a rate that beats the Last Resort benchmark — all five at once. See
      <a href="methodology.html">Methodology &amp; Corrections</a> for the full criteria.</p>
      <p class="note">Data checked <span id="checked-date">2026-10-17</span>. &ldquo;Not confirmed&rdquo; means the
      source does not publish it — we never guess a fee, term, or rate.</p>
      <div id="offers"><!-- rendered from data/supplier_offers.json --></div>
    </section>

    <!-- ============ AGGREGATION CHECKER ============ -->
    <section class="frame" id="towns" aria-labelledby="towns-h">
      <h2 id="towns-h">== FIRST: CHECK YOUR TOWN ==</h2>
      <p>Eight Rhode Island towns run <strong>municipal aggregation</strong> programs. If you live in one, you were
      likely <strong>auto-enrolled</strong> — your real baseline is your town&rsquo;s rate, not the Last Resort rate,
      and most supplier offers on this page would be a downgrade or a wash.</p>
      <div class="field">
        <label for="town-select">SELECT YOUR TOWN</label>
        <select id="town-select">
          <option value="">-- SELECT A TOWN --</option>
          <!-- town options rendered from data/aggregation_towns.json -->
          <option value="__none">MY TOWN IS NOT LISTED</option>
        </select>
      </div>
      <div id="town-result" class="readout" aria-live="polite">
        <p class="note">&gt; SELECT A TOWN TO SEE ITS PROGRAM, RATES, AND WHAT THEY COST AT YOUR USAGE.</p>
      </div>
    </section>

    <!-- ============ WINTER CREDITS ============ -->
    <section class="frame" id="credits" aria-labelledby="credits-h">
      <h2 id="credits-h">== WINTER BILL CREDITS (YOU KEEP THESE IF YOU SWITCH) ==</h2>
      <p>Two state credits land on Rhode Island electric bills this year. Both are <strong>fixed-dollar line
      items on the delivery side</strong> of your Rhode Island Energy bill — they have nothing to do with who
      supplies your electricity:</p>
      <ul class="promise-list">
        <li><strong>Hold Harmless credit — $14.50/month</strong>, on bills rendered <strong>October 2026
        through September 2027</strong> (a full 12 months, not just winter). Every active electric distribution
        account gets it. Tariff R.I.P.U.C. No. 2304 (PUC Docket 25-45-GE).</li>
        <li><strong>RGGI emergency credit — $20.45/month</strong> in each of the <strong>January, February and
        March 2027</strong> billing periods, for distribution accounts in rate classes <strong>A-16</strong>
        (standard residential) and <strong>A-60</strong> (low-income residential) — which is effectively every
        Rhode Island household. Tariff R.I.P.U.C. No. 2309 (PUC Docket 26-28-EL).</li>
      </ul>
      <p>In January&ndash;March 2027 the two stack: <strong>$34.95/month</strong>. Most comparison sites ignore
      these credits entirely. We show them as a separate line in the math above — they lower every option
      equally, so they never inflate a supplier&rsquo;s &ldquo;saving,&rdquo; and the supply-only savings
      figures stay clean.</p>
      <p class="confirm-box"><strong>CONFIRMED:</strong> Switching suppliers does not cost you these credits —
      they&rsquo;re on the delivery side of your bill, and every Rhode Island household gets them. Third-party
      supplier customers and municipal aggregation customers keep both credits on the same terms as
      default-service customers, because the credits follow your Rhode Island Energy distribution account —
      not your supplier.</p>
    </section>

    <!-- ============ HONEST BROKER PROMISE ============ -->
    <section class="frame" id="promise" aria-labelledby="promise-h">
      <h2 id="promise-h">== THE HONEST-BROKER PROMISE ==</h2>
      <ul class="promise-list">
        <li><strong>We rank by real cost, never by who pays us.</strong> Position on this page cannot be bought.</li>
        <li><strong>Referral fees are disclosed on the card.</strong> If a supplier ever pays us when someone enrolls, that offer&rsquo;s card will say so, in plain text, on the card itself.</li>
        <li><strong>&ldquo;Stay put&rdquo; is a valid answer.</strong> Between 2017 and 2024, Rhode Islanders on third-party supply paid <strong>$61.6 million more</strong> than they would have on default service (Green Energy Consumers Alliance analysis of RI DPUC data). If the default rate or your town&rsquo;s aggregation is the lowest-cost option for your usage among the offers we list, we say so.</li>
        <li><strong>Every number is date-stamped and labeled.</strong> Verified means verified. Advertised means advertised. Unknown means &ldquo;not confirmed&rdquo; — never a guess.</li>
        <li><strong>Track records travel with the offers.</strong> A supplier&rsquo;s Rhode Island history is shown on its card, including when that history is bad.</li>
      </ul>
    </section>

    <!-- ============ FAQ ============ -->
    <section class="frame" id="faq" aria-labelledby="faq-h">
      <h2 id="faq-h">== FREQUENTLY ASKED QUESTIONS ==</h2>

      <details>
        <summary>What is the Last Resort rate?</summary>
        <p>The Last Resort rate (Last Resort Service) is Rhode Island Energy&rsquo;s default supply rate — what you
        pay for the supply part of your bill if you have not chosen a third-party supplier or been auto-enrolled in
        a municipal aggregation program. For <strong>October 1, 2026 through March 31, 2027 it is 17.029&cent;/kWh</strong>,
        approved by the RI Public Utilities Commission (tariff R.I.P.U.C. No. 2096). It resets every April 1 and
        October 1; the summer 2026 rate was 11.092&cent;/kWh. It is the rate to beat — and in winter, beating it
        honestly is harder than the ads suggest.</p>
      </details>

      <details>
        <summary>Is switching worth it?</summary>
        <p>Sometimes — but often not. An analysis of RI Division of Public Utilities data found that between 2017
        and 2024, third-party supply customers paid <strong>$61.6 million more</strong> in total than they would have
        on default service, and nearly every large supplier cost its customers money on average. Switching only
        makes sense when all of these hold: the rate clearly beats the Last Resort rate after any fees, the term
        spans the expensive winter months instead of expiring into them, the early-termination fee is low or $0,
        and the supplier&rsquo;s Rhode Island track record is clean. If your town has municipal aggregation, you are
        probably already close to the lowest-cost option in the offers we list. Staying put is a valid answer.</p>
      </details>

      <details>
        <summary>What is municipal aggregation?</summary>
        <p>Municipal aggregation (community electricity) is when a city or town buys electricity supply in bulk for
        its residents. Eligible households are auto-enrolled, and anyone can leave or change tiers at any time with
        no fee. In Rhode Island, eight municipalities run programs with consultant Good Energy and supplier NextEra
        Energy Services: Barrington, Central Falls, Narragansett, Newport, North Kingstown, Portsmouth, Providence,
        and South Kingstown. For winter 2026&ndash;27 their Standard rate — the community default — is
        16.929&cent;/kWh, and the Basic tier is 16.705&cent;/kWh. Use the town checker above to see your town&rsquo;s
        full pricing. North Providence does not have a program.</p>
      </details>

      <details>
        <summary>Do contracts auto-renew in RI?</summary>
        <p><strong>No.</strong> Rhode Island law prohibits residential electricity supplier contracts from
        auto-renewing. When your term ends, the contract ends — you choose a new offer or return to the default
        Last Resort service. Two cautions: a supplier can still <em>offer</em> you a new contract at a new rate when
        your term ends, so read end-of-term mail carefully; and a low introductory rate that expires mid-winter can
        leave you shopping at the worst moment. This site flags terms and renewal behavior whenever the source
        publishes them.</p>
      </details>

      <details>
        <summary>What&rsquo;s the max early-termination fee?</summary>
        <p>By Rhode Island law, an early-termination fee on a residential electricity supply contract is capped at
        <strong>$50</strong> — or twice your average monthly bill, if that is less (R.I. Gen. Laws
        &sect; 39-26.7-6(a); Division rule 815-RICR-30-05-2 &sect; 2.6). Many plans charge $0. This site
        shows each plan&rsquo;s fee when it is confirmed (for example, Direct Energy&rsquo;s Live Brighter 12 is
        confirmed at $0 on the supplier&rsquo;s own site) and marks it &ldquo;not confirmed&rdquo; when the source
        does not publish it — we never guess.</p>
      </details>

      <details>
        <summary>Do I lose the state winter credits if I switch suppliers?</summary>
        <p><strong>No.</strong> Both state credits are fixed-dollar line items on the <em>delivery</em> side of
        your Rhode Island Energy bill, and neither one is tied to who supplies your electricity. The Hold Harmless
        credit is $14.50/month on bills rendered October 2026&ndash;September 2027 (Tariff R.I.P.U.C. No. 2304).
        The RGGI emergency credit is $20.45/month in each of the January, February and March 2027 billing periods,
        for distribution accounts in rate classes A-16 and A-60 — the standard and low-income residential classes
        (Tariff R.I.P.U.C. No. 2309). Because the credits follow your distribution account, third-party supplier
        customers and municipal aggregation customers keep both, on the same terms as everyone else.</p>
      </details>
    </section>
  </main>

  <footer class="foot">
    <p>RI RATE CHECK — an honest-broker comparison for Rhode Island households, operated by the Gregorio Companies
    digital LLC. This site is for <strong>information only</strong> and is <strong>not affiliated with Rhode Island
    Energy, the RI Public Utilities Commission, the RI Division of Public Utilities and Carriers, Empower RI,
    or any listed supplier</strong>.</p>
    <p>Rates are supply rates in cents per kWh and are <strong>estimates as of the stated checked date</strong> shown
    on every card, with its data source. Suppliers can change offers at any time. <strong>Verify all terms — rate,
    term, fees, and renewal behaviour — with the supplier before enrolling.</strong> Enrollment links are not live
    on this site yet — offers get linked only after they are verified for a specific ZIP, any referral terms are
    approved, and any referral fee is disclosed on the offer&rsquo;s card.</p>
    <p><a href="methodology.html">Methodology &amp; Corrections</a> &middot; <a href="affiliate-disclosure.html">Affiliate Disclosure</a> &middot; <a href="terms.html">Terms of Use</a> &middot; <a href="privacy.html">Privacy Policy</a></p>
    <p class="prompt-line">&gt; END OF FILE <span class="cursor" aria-hidden="true"></span></p>
  </footer>
</div>

<script src="app.js" defer></script>
</body>
</html>
