<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Rhode Island heating oil prices — the state average, honestly labeled | RI Oil Check</title>
<meta name="description" content="The official Rhode Island residential heating oil average (SHOPP/EIA state survey), with the trend, what a fair price looks like against it, COD vs full-service explained, propane prices and your disclosure rights under RI law, and heating assistance pointers. A benchmark, not a quote.">
<link rel="stylesheet" href="styles.css">
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the state average price for heating oil in Rhode Island?",
      "acceptedAnswer": { "@type": "Answer", "text": "The state average is the Rhode Island residential heating oil price published by the U.S. Energy Information Administration (EIA) under the State Heating Oil and Propane Program (SHOPP), a joint survey run with state energy offices on Form EIA-877. For the week of October 12, 2026 it was $6.304 per gallon. It is a statewide survey average of the residential credit price charged by full-service dealers, excluding taxes — one average for the whole state. SHOPP does not publish county-level or dealer-level prices." }
    },
    {
      "@type": "Question",
      "name": "Is the state average the price I should pay?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. The state average is a benchmark — the price to measure a quote against — not a quote and not a target. It tracks the full-service, on-credit price, which is the top of the market's normal range. If you buy from a full-service dealer and use its service contract, automatic delivery, and credit terms, paying around the average can be fair. If you buy COD (cash on delivery, will-call), a fair price should be well under the average, because you are not buying the service bundle. Green Energy Consumers Alliance documents that its buying-group members typically save 10 to 50 cents per gallon compared to the state survey average." }
    },
    {
      "@type": "Question",
      "name": "Why is my dealer's price higher than a COD price?",
      "acceptedAnswer": { "@type": "Answer", "text": "Because the two prices buy different things. A full-service price bundles the fuel with 24/7 emergency service, a service contract, automatic delivery so you do not have to watch the tank gauge, budget or equal-payment plans, and credit terms. A COD price is fuel only: you watch your own tank, call for each delivery yourself, and pay up front. The fuel itself is the same No. 2 heating oil. The gap between the two is the price of the service bundle — it is worth paying only if you actually use the services." }
    },
    {
      "@type": "Question",
      "name": "Do propane dealers have to tell me their price per gallon?",
      "acceptedAnswer": { "@type": "Answer", "text": "Yes — on request. Under Rhode Island law (RI Gen. Laws section 5-83-2), a propane dealer must, on request, disclose the estimated price per gallon and applicable charges. A propane dealer also may not charge fees above the delivered cost per gallon unless those fees were disclosed in advance and are itemized on the invoice. There is no equivalent disclosure statute for heating oil." }
    },
    {
      "@type": "Question",
      "name": "How often does the benchmark update?",
      "acceptedAnswer": { "@type": "Answer", "text": "During the heating season, October through March, SHOPP prices are collected as of each Monday and published by EIA on Wednesdays at 1:00 PM Eastern. From April through September, prices are collected only on the second Monday of each month, and no monthly averages are published for that period. The prior week's average may be revised in the next release to account for late submissions and corrections." }
    },
    {
      "@type": "Question",
      "name": "Does Rhode Island regulate heating oil or propane prices?",
      "acceptedAnswer": { "@type": "Answer", "text": "No. The RI Office of Energy Resources states that Rhode Island does not regulate retail sales of heating oil and propane, and that sales are managed primarily by local fuel dealers. That is exactly why the same fuel can sell at materially different prices on the same day — and why a public benchmark matters. Propane customers do have specific disclosure rights under RI Gen. Laws section 5-83, and any consumer can file a complaint with the RI Attorney General's Consumer Protection Unit." }
    }
  ]
}
</script>
</head>
<body>
<div class="wrap">

  <header class="masthead">
    <pre class="logo" aria-hidden="true">+==============================================+
|  RI_OIL_CHECK  v1.0  //  PROVIDENCE, RI      |
+==============================================+</pre>
    <p class="tagline">RHODE ISLAND HEATING OIL &amp; PROPANE PRICES, BENCHMARKED HONESTLY.<br>
    NO DEALER LISTINGS. NO QUOTE GAMES. <span class="prompt">&gt;</span><span class="cursor" aria-hidden="true"></span></p>
    <nav class="nav" aria-label="Sections">
      <a href="#this-week">[ THIS WEEK ]</a>
      <a href="#fair-price">[ FAIR PRICE ]</a>
      <a href="#cod">[ COD vs FULL-SERVICE ]</a>
      <a href="#propane">[ PROPANE ]</a>
      <a href="#help">[ HELP PAYING ]</a>
      <a href="#faq">[ FAQ ]</a>
      <a href="methodology.html">[ METHODOLOGY ]</a>
    </nav>
  </header>

  <main>
    <!-- ============ HERO / THIS WEEK ============ -->
    <section class="frame hero" id="this-week" aria-labelledby="hero-h">
      <h1 id="hero-h">Rhode Island heating oil prices: the state average this week</h1>
      <div id="benchmark-hero"><!-- rendered from data/prices.json --></div>
      <p class="big">That is the <strong>state survey (SHOPP/EIA) average</strong> for residential heating oil:
      full-service dealers, credit price, taxes excluded. Prices are collected Monday and published Wednesday —
      <strong>a benchmark, not a quote</strong>. No dealer sells &ldquo;the average&rdquo;; every dealer sets its
      own price. This page exists so you can measure the price you are quoted against the one official number
      Rhode Island publishes.</p>
      <h3 class="subhead">&gt; TREND — RHODE ISLAND RESIDENTIAL HEATING OIL</h3>
      <div id="trend" class="readout" aria-live="polite"><!-- rendered from data/prices.json --></div>
      <p class="note">Source: U.S. Energy Information Administration (EIA), Weekly Heating Oil and Propane Prices
      (State Heating Oil and Propane Program — SHOPP). Series page:
      <a href="https://www.eia.gov/dnav/pet/PET_PRI_WFR_DCUS_SRI_W.htm" rel="noopener">EIA RI weekly heating oil
      and propane prices</a>. Data checked <span id="checked-date">2026-10-17</span>. Prior-week values may be
      revised in the next release.</p>
      <p class="note"><strong>Seasonal cadence:</strong> SHOPP is <strong>weekly October&ndash;March</strong>
      (collected Monday, published Wednesday at 1:00 PM ET) and <strong>monthly April&ndash;September</strong>
      (collected on the second Monday of each month). The benchmark&rsquo;s heartbeat changes with the season —
      and so does this page&rsquo;s.</p>
    </section>

    <!-- ============ FAIR PRICE ============ -->
    <section class="frame" id="fair-price" aria-labelledby="fair-h">
      <h2 id="fair-h">== WHAT A FAIR PRICE LOOKS LIKE ==</h2>
      <p>Rhode Island does not regulate retail heating oil prices, and no public authority publishes dealer-level
      prices — so &ldquo;fair&rdquo; can only be judged <strong>relative to the benchmark</strong>. The bands below
      are computed from this week&rsquo;s state average and documented price dispersion. <strong>Every band is
      labeled as a documented range or a computed guide. None of them is a live dealer price</strong> — dealers
      change prices daily, and only a dealer can quote you.</p>
      <div id="fair-bands"><!-- rendered from data/prices.json --></div>
      <p>What the dispersion is worth: at October 2026 price levels, a 50&cent;/gal gap on a single 150-gallon
      delivery is <strong>$75</strong> — and it compounds across a winter&rsquo;s deliveries. (Illustrative
      arithmetic on the documented ranges above; actual household use varies.)</p>
      <p class="note">Dispersion sources: <a href="https://www.greenenergyconsumers.org/heatingoil/membership/howmembershipworks" rel="noopener">Green
      Energy Consumers Alliance — how membership works</a> (member savings vs the state survey; the survey average
      is drawn from full-service dealers; participating dealers&rsquo; average contracted retail margin is
      85&cent;/gal over wholesale, and 30-day billing prices usually run 5&ndash;10&cent;/gal above prompt-pay) ·
      <a href="https://heatfleet.com/heating_oil_prices/RI-Rhode_Island.html" rel="noopener">HeatFleet — RI heating
      oil prices</a> and <a href="https://www.cheapestoil.com/RhodeIsland" rel="noopener">CheapestOil — Rhode
      Island</a> (October 2026 posted discount prices). Aggregator postings are unverified by their own admission —
      we cite them only as documented ranges, never as prices you can necessarily get.</p>
    </section>

    <!-- ============ COD vs FULL-SERVICE ============ -->
    <section class="frame" id="cod" aria-labelledby="cod-h">
      <h2 id="cod-h">== COD vs FULL-SERVICE: WHAT THE GAP BUYS ==</h2>
      <p>The same No. 2 heating oil, delivered out of the same marine terminals, sells at two very different
      prices in Rhode Island — because the per-gallon price is only part of what a full-service dealer sells.
      Neither way of buying is &ldquo;the smart one&rdquo; for everyone. The honest question is whether you use
      what the gap pays for.</p>
      <div class="cols">
        <div class="card">
          <h3>FULL-SERVICE (AROUND THE STATE AVERAGE)</h3>
          <p class="note">What the higher per-gallon price buys:</p>
          <ul>
            <li><strong>24/7 emergency service</strong> and a service contract — a no-heat call at 2 AM is covered, not a scramble.</li>
            <li><strong>Automatic delivery</strong> — the dealer tracks your usage and fills the tank before it runs dry (this is the &ldquo;keep-full&rdquo; basis the state survey prices).</li>
            <li><strong>Budget / equal-payment plans</strong> — winter&rsquo;s cost spread across the year instead of landing in a few large fills.</li>
            <li><strong>Credit terms</strong> — delivery now, bill on account (note: 30-day billing typically runs 5&ndash;10&cent;/gal above prompt-pay pricing, per Green Energy Consumers Alliance).</li>
            <li><strong>Price-protection options</strong> — cap and pre-buy plans are usually full-service products.</li>
          </ul>
        </div>
        <div class="card">
          <h3>COD / WILL-CALL (WELL UNDER THE AVERAGE)</h3>
          <p class="note">What you give up — and take on yourself:</p>
          <ul>
            <li><strong>You watch the tank.</strong> Nobody fills it automatically; run it dry and you may pay for an emergency delivery and a burner prime/restart.</li>
            <li><strong>You pay up front</strong> — cash on delivery or prepay, per fill, at the day&rsquo;s price.</li>
            <li><strong>No service contract.</strong> Repairs and annual tune-ups are arranged and paid for separately.</li>
            <li><strong>Minimum deliveries apply</strong> — discount pricing is typically quoted for a set fill size (the October 2026 postings above were priced on 150-gallon orders).</li>
            <li><strong>The fuel is identical.</strong> The gap does not buy better oil — it buys the service bundle in the other column.</li>
          </ul>
        </div>
      </div>
      <h3 class="subhead">&gt; WHO SHOULD BUY WHICH WAY</h3>
      <ul class="promise-list">
        <li><strong>Full-service fits</strong> if your equipment is older or unreliable, you cannot easily monitor the tank (travel, tenants, a second home), or you need winter costs smoothed into a budget plan and value one phone number when the heat stops.</li>
        <li><strong>COD fits</strong> if your equipment is newer and serviced, you are comfortable watching the gauge and timing fills, and you can pay per fill. The documented gap — roughly 30&ndash;70&cent;/gal at October 2026 levels — is real money across a winter.</li>
        <li><strong>The middle path:</strong> a buying group such as Green Energy Consumers Alliance pairs members with a full-service dealer at a capped margin — documented savings of 10&ndash;50&cent;/gal vs the state survey average, with the service bundle kept.</li>
      </ul>
      <p class="warning-box"><strong>WATCH OUT:</strong> Comparing a COD posting to your full-service bill — or the
      reverse — without naming the basis is how households get misled. Always ask which of these a quoted price is,
      what the delivery minimum is, and what fees sit on top of the per-gallon price, before you order.</p>
    </section>

    <!-- ============ PROPANE ============ -->
    <section class="frame" id="propane" aria-labelledby="propane-h">
      <h2 id="propane-h">== PROPANE: BENCHMARK + YOUR RIGHTS UNDER RI LAW ==</h2>
      <div id="propane-benchmark"><!-- rendered from data/prices.json --></div>
      <h3 class="subhead">&gt; YOUR RIGHTS UNDER RI LAW — RI GEN. LAWS §5-83</h3>
      <p>Propane is the one delivered fuel where Rhode Island law gives you explicit disclosure rights. Most
      propane customers do not know they have them:</p>
      <ul class="promise-list">
        <li><strong>Fees above the delivered per-gallon cost are not allowed unless disclosed in advance and
        itemized on the invoice.</strong> A propane dealer may not charge fees above the delivered cost per gallon
        unless they were disclosed to you in advance and appear, itemized, on your invoice
        (<a href="https://codes.findlaw.com/ri/title-5-businesses-and-professions/ri-gen-laws-sect-5-83-2/" rel="noopener">RI Gen. Laws §5-83-2</a>).</li>
        <li><strong>On request, your dealer must disclose the price.</strong> Ask, and the dealer must tell you
        the estimated price per gallon and the applicable charges (§5-83-2).</li>
        <li><strong>Guaranteed-price and prepaid contracts have legal terms too</strong> — the same chapter covers
        them (§5-83-1), and violations of the chapter carry a fine of up to $500 (§5-83-6).</li>
      </ul>
      <p class="confirm-box"><strong>USE IT:</strong> Before any propane delivery, ask for the estimated price per
      gallon and every applicable charge — it is your right under §5-83-2, not a favor. After delivery, check that
      any fee above the per-gallon cost was disclosed in advance and is itemized on the invoice. If a dealer will
      not do either, you can file a complaint with the RI Attorney General&rsquo;s Consumer Protection Unit:
      <a href="https://riag.ri.gov/forms/consumer-complaint" rel="noopener">riag.ri.gov/forms/consumer-complaint</a>.</p>
      <p class="warning-box"><strong>NO EQUIVALENT FOR HEATING OIL:</strong> There is no disclosure statute like
      §5-83 for heating oil. For oil, your protection is the benchmark on this page, a direct question to the
      dealer before you order, and the same AG complaint route if a dealer misleads you.</p>
    </section>

    <!-- ============ HELP PAYING ============ -->
    <section class="frame" id="help" aria-labelledby="help-h">
      <h2 id="help-h">== HELP PAYING FOR HEAT ==</h2>
      <p>If a fill is out of reach, there is help that does not cost you anything and does not sell you anything.
      This site makes no money from this section and never will.</p>
      <ul class="promise-list">
        <li><strong>LIHEAP — Low Income Home Energy Assistance Program.</strong> Federal grants that help eligible
        Rhode Island households pay heating costs, administered by the RI Department of Human Services (DHS) through
        local Community Action Agencies. There are two parts: <strong>heating assistance</strong> (a grant toward
        your heating costs, usually paid to your fuel vendor) and <strong>crisis assistance</strong> (help with a
        shut-off, an inability to pay for a fuel delivery, or a heating system failure that cannot be repaired).
        Households at or below 60% of Rhode Island&rsquo;s median income are income-eligible; you do not need to be
        on public assistance or behind on a bill to qualify, and both renters and homeowners can apply. The FFY 2027
        application period opened <strong>October 1, 2026</strong> — apply early, through DHS online or your local
        Community Action Agency: <a href="https://dhs.ri.gov/programs-and-services/energy-assistance-programs-heating/low-income-home-energy-assistance-1" rel="noopener">RI DHS LIHEAP</a>.</li>
        <li><strong>Do not let the tank run dry while you wait.</strong> If you are facing a no-heat crisis, say so
        when you apply — crisis assistance exists specifically for deliverable-fuel emergencies and unrepairable
        heating-system failures.</li>
        <li><strong>Something wrong with a bill or a delivery?</strong> The RI Attorney General&rsquo;s Consumer
        Protection Unit accepts complaints about businesses operating in Rhode Island:
        <a href="https://riag.ri.gov/forms/consumer-complaint" rel="noopener">file a consumer complaint</a>.</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 state average price?</summary>
        <p>The state average is the Rhode Island residential heating oil price published by the U.S. Energy
        Information Administration (EIA) under the State Heating Oil and Propane Program (SHOPP), a joint survey
        run with state energy offices on Form EIA-877. For the <strong>week of October 12, 2026 it was
        $6.304 per gallon</strong>. It is a statewide survey average of the residential <em>credit</em> price
        charged by full-service dealers, excluding taxes — one average for the whole state. SHOPP does not publish
        county-level or dealer-level prices, and the average may be revised in the following week&rsquo;s release.</p>
      </details>

      <details>
        <summary>Is the state average the price I should pay?</summary>
        <p><strong>No.</strong> The state average is a benchmark — the price to measure a quote against — not a
        quote and not a target. It tracks the full-service, on-credit price, which is the top of the market&rsquo;s
        normal range. If you buy from a full-service dealer and use its service contract, automatic delivery, and
        credit terms, paying around the average can be fair. If you buy COD (cash on delivery, will-call), a fair
        price should be well under the average, because you are not buying the service bundle. Green Energy
        Consumers Alliance documents that its buying-group members typically save <strong>10&ndash;50 cents per
        gallon</strong> compared to the state survey average.</p>
      </details>

      <details>
        <summary>Why is my dealer&rsquo;s price higher than a COD price?</summary>
        <p>Because the two prices buy different things. A full-service price bundles the fuel with 24/7 emergency
        service, a service contract, automatic delivery so you do not have to watch the tank gauge, budget or
        equal-payment plans, and credit terms. A COD price is fuel only: you watch your own tank, call for each
        delivery yourself, and pay up front. The fuel itself is the same No. 2 heating oil. The gap between the two
        is the price of the service bundle — worth paying only if you actually use the services. See
        <a href="#cod">COD vs FULL-SERVICE</a> above.</p>
      </details>

      <details>
        <summary>Do propane dealers have to tell me their price per gallon?</summary>
        <p><strong>Yes — on request.</strong> Under Rhode Island law (RI Gen. Laws §5-83-2), a propane dealer must,
        on request, disclose the estimated price per gallon and applicable charges. A propane dealer also may not
        charge fees above the delivered cost per gallon unless those fees were disclosed in advance and are
        itemized on the invoice. There is no equivalent disclosure statute for heating oil.</p>
      </details>

      <details>
        <summary>How often does the benchmark update?</summary>
        <p>During the heating season, <strong>October through March</strong>, SHOPP prices are collected as of each
        Monday and published by EIA on <strong>Wednesdays at 1:00 PM Eastern</strong>. From <strong>April through
        September</strong>, prices are collected only on the second Monday of each month, and no monthly averages
        are published for that period. The prior week&rsquo;s average may be revised in the next release to account
        for late submissions and corrections — so treat each week&rsquo;s number as the best official figure, not
        a permanent one.</p>
      </details>

      <details>
        <summary>Does Rhode Island regulate heating oil prices?</summary>
        <p><strong>No.</strong> The RI Office of Energy Resources states: &ldquo;Rhode Island does not regulate
        retail sales of heating oil and propane. Sales are managed primarily by local fuel dealers.&rdquo; That is
        exactly why the same fuel can sell at materially different prices on the same day — and why a public
        benchmark matters. (Over one-third of Rhode Island homes heat with oil and propane, per the same OER page.)
        Propane customers do have specific disclosure rights under RI Gen. Laws §5-83, and any consumer can file a
        complaint with the RI Attorney General&rsquo;s Consumer Protection Unit.</p>
      </details>
    </section>
  </main>

  <footer class="foot">
    <p><strong>Disclaimer:</strong> RI Oil Check is for information only. Every price on this page is a statewide
    survey average from the State Heating Oil and Propane Program (SHOPP/EIA) or a documented range computed from
    it — <strong>not a dealer quote</strong>, and no price here is attributed to any individual dealer. This site
    is <strong>not affiliated with</strong> the RI Office of Energy Resources, the U.S. Energy Information
    Administration (EIA), or any fuel dealer. Heating oil and propane prices change daily; <strong>verify the
    actual price and all fees with the dealer before ordering</strong>. Operated by the Gregorio Companies
    digital LLC.</p>
    <p><a href="methodology.html">[ METHODOLOGY ]</a>
    <a href="affiliate-disclosure.html">[ AFFILIATE DISCLOSURE ]</a>
    <a href="terms.html">[ TERMS ]</a>
    <a href="privacy.html">[ PRIVACY ]</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>
