OctopusR for optimising household energy use

Author

Simon Thelwall

Background

I’ve got solar PV, battery storage, an ASHP and an EV. Finding the right energy tariff to get the most electricity for my use isn’t straightforward. I’m with Octopus Energy, and they have a whole load of different tariffs.

Fortunately, Octopus being the modern sort of a company, they have an API which customers can query and, fortunately, there’s an R package OctopusR which interfaces with that API to make my life easy. I’m going to use that package to look at my electricty usage over the last year and hopefully optimise my tariff choices and battery settings.

Methods

The OctopusR package is available on CRAN, the code is on GitHub and there are nice github pages on the package here.

To access the API, you need the API key for your account, the MPAN numbers for your meters and the meter serial number. There’s documentation on the API on the Octopus developer pages and Guy Lipman has a nice write-up on his blog.

If you have PV, then you have two MPAN numbers, one for import from the grid and one for export. Octopus don’t tell you which is which, but the data make it obvious.

I’m going to use the get_consumption() function to pull my consumption and export data for the calendar year 2024 into R and do some basic calculations with dplyr. With that data, and some transcribed data about tariff costs for my local area I should be able to find the best tariff for me.

Code

library(octopusR)
library(dplyr)
library(ggplot2)
library(viridis)
library(lubridate)

# I've got my api key and mpan numbers stored in text files so that they're not exposed here.
set_api_key(readLines(con = "../api_key.txt"))
set_meter_details(meter_type = "electricity",
                  mpan_mprn = readLines("../elec_mtr_mpan.txt"),
                  serial_number = readLines("../elec_mtr_srl_num.txt"))
exp_mpan <- readLines("../elec_mtr_mpan_exprt.txt")

# consumption data
elec_use <- get_consumption(meter_type = "elec", tz = "GMT", 
                            period_from = dmy("01-01-2024"),
                            period_to = dmy("31-12-2024"), 
                            group_by = "hour") %>% 
  mutate(mnth = month(interval_start), hr = hour(interval_start))
head(elec_use)

# A tibble: 6 x 5
  consumption interval_start      interval_end         mnth    hr
        <dbl> <dttm>              <dttm>              <dbl> <int>
1       1.23  2024-12-31 00:00:00 2024-12-31 01:00:00    12     0
2       0.237 2024-12-30 23:00:00 2024-12-31 00:00:00    12    23
3       0.227 2024-12-30 22:00:00 2024-12-30 23:00:00    12    22
4       0.347 2024-12-30 21:00:00 2024-12-30 22:00:00    12    21
5       1.50  2024-12-30 20:00:00 2024-12-30 21:00:00    12    20
6       1.38  2024-12-30 19:00:00 2024-12-30 20:00:00    12    19

Code

# export data
elec_exp <- get_consumption(meter_type = "elec", tz = "GMT", 
                             mpan_mprn = exp_mpan, 
                             period_from = dmy("01-01-2024"),
                             period_to = dmy("31-12-2024"), 
                             group_by = "hour") %>% 
  mutate(mnth = month(interval_start), hr = hour(interval_start))
head(elec_exp)

# A tibble: 6 x 5
  consumption interval_start      interval_end         mnth    hr
        <dbl> <dttm>              <dttm>              <dbl> <int>
1           0 2024-12-31 00:00:00 2024-12-31 01:00:00    12     0
2           0 2024-12-30 23:00:00 2024-12-31 00:00:00    12    23
3           0 2024-12-30 22:00:00 2024-12-30 23:00:00    12    22
4           0 2024-12-30 21:00:00 2024-12-30 22:00:00    12    21
5           0 2024-12-30 20:00:00 2024-12-30 21:00:00    12    20
6           0 2024-12-30 19:00:00 2024-12-30 20:00:00    12    19

There is an API endpoint that gives prices for the Agile and Go tariffs, but there isn’t an R function for that yet, so I haven’t used it here. I have checked the Octopus website for the current (late February) prices for my local area (East England).

Code

elec_use <- elec_use %>% 
  mutate(flex_cost = consumption * 0.2557, 
         aira_zero_cost = case_when(
           # 
           between(hour(interval_start), 16, 19) ~ consumption * 0.4047, 
           between(hour(interval_start), 4, 7)   ~ consumption * 0.1323, 
           between(hour(interval_start), 13, 16)   ~ consumption * 0.1323,
           between(hour(interval_start), 22, 00) ~ consumption * 0.1323, 
           TRUE ~ consumption * 0.2698 
         ),
         flux_cost = case_when(
           # https://octopus.energy/smart/flux/
           between(hour(interval_start), 02, 05) ~ consumption * 0.1534, 
           between(hour(interval_start), 16, 19) ~ consumption * 0.2744, 
           TRUE ~ consumption * 0.2557
         ), 
         go_cost = case_when(
           # https://octopus.energy/smart/go/
           between(hour(interval_start), 01, 05) ~ consumption * 0.085, 
           TRUE ~ consumption * 0.271
         ),
         intel_go_cost = case_when(
           # https://octopus.energy/smart/go/
           between(hour(interval_start), 00, 05) ~ consumption * 0.07, 
           TRUE ~ consumption * 0.271
         )
         )

Results

Consumption costs under different tariffs

Total cost (£) per calendar month, 2024

Code

elec_cost <- elec_use %>% 
  group_by(mnth) %>% 
  summarise(across(.cols = c(flex_cost, aira_zero_cost, flux_cost, go_cost, 
                             intel_go_cost), .fns = sum)) %>% 
  mutate(across(.cols = c(flex_cost, aira_zero_cost, flux_cost, go_cost, 
                             intel_go_cost), .fns = round, digits = 2))
elec_cost

# A tibble: 12 x 6
    mnth flex_cost aira_zero_cost flux_cost go_cost intel_go_cost
   <dbl>     <dbl>          <dbl>     <dbl>   <dbl>         <dbl>
 1     1    302.           282.      284.    275.          262.  
 2     2    159            144.      150.    144.          135.  
 3     3    115.            94.6     104.     97.9          90.4 
 4     4     55.1           39.0      44.4    37.6          33.1 
 5     5      8.74           8.31      7.86    7.17          6.58
 6     6      7.17           5.95      6.19    5.48          5.08
 7     7      3.51           3.66      3.32    3.19          2.83
 8     8      5.01           5.26      4.64    4.34          3.69
 9     9     49.0           45.5      44.2    41.1          37.2 
10    10    128.           117.      117     109.           99.9 
11    11    260.           260.      249.    241.          231.  
12    12    278.           269.      269.    266.          256.

So, for January, I could have saved myself £39.48 if I had been on the Intelligent Go tariff, rather than the Flexible tariff.

Over the year, these different costs sum to:

Code

elec_cost_yr <- elec_use %>% 
  summarise(across(.cols = c(flex_cost, aira_zero_cost, flux_cost, go_cost, 
                             intel_go_cost), .fns = sum)) %>% 
  mutate(across(.cols = c(flex_cost, aira_zero_cost, flux_cost, go_cost, 
                             intel_go_cost), .fns = round, digits = 2))
elec_cost_yr

# A tibble: 1 x 5
  flex_cost aira_zero_cost flux_cost go_cost intel_go_cost
      <dbl>          <dbl>     <dbl>   <dbl>         <dbl>
1     1370.          1275.     1283.   1233.         1164.

So, with the Intelligent Go tariff, I could have saved myself £206.5 (15.1%), which is rather less that I had hoped for.

However, I haven’t factored in the daily standing charge, but these are the same for both tariffs at 48.70p / day.

Savings by altering my battery plan

I’ve got a 10 kWh battery system. If I set that to charge on a cheap overnight tariff and then discharge it when that cheap overnight tariff runs out, how much will I save?

I’m not quite sure how to calculate this, but if, per day, my kWh is > 10, I can shift that 10 kWh to the night time load.

So, below I’ve generated an altered consumption column where the load is 10 kWh lower if it’s in the peak period for Intelligent Go and 10 kWh higher in the off-peak period and then used these values to calculate the cost in £.

Code

elec_cost_yr_batt <- elec_use %>% 
  mutate(dt = format(interval_start, "%Y-%m-%d"), 
         low_cost_hr = if_else(between(hour(interval_start), 00, 05), 1, 0)) %>%
  group_by(low_cost_hr, dt) %>%
  summarise(consumption = sum(consumption)) %>% 
  ungroup() %>% 
  arrange(dt, low_cost_hr) %>% 
  mutate(gt_10_kwh = if_else(low_cost_hr == 0 & consumption >= 10, 1, 0)) %>% 
  group_by(dt) %>% 
  mutate(gt_10_day = max(gt_10_kwh)) %>% 
  ungroup() %>% 
  mutate(consumption_2 = case_when(
    low_cost_hr == 0 & gt_10_day == 1 ~ consumption - 10, 
    low_cost_hr == 0 & gt_10_day == 0 ~ 0,
    low_cost_hr == 1                  ~ consumption + 10
      ), 
    intel_go_cost = if_else(low_cost_hr == 1, 
                            consumption_2 * 0.07, 
                            consumption_2 * 0.271)
    )

# table(is.na(elec_cost_yr_batt$intel_go_cost))
head(elec_cost_yr_batt)

# A tibble: 6 x 7
  low_cost_hr dt     consumption gt_10_kwh gt_10_day consumption_2 intel_go_cost
        <dbl> <chr>        <dbl>     <dbl>     <dbl>         <dbl>         <dbl>
1           0 2024-~       19.0          1         1          9.02         2.44 
2           1 2024-~        3.82         0         1         13.8          0.968
3           0 2024-~       18.7          1         1          8.68         2.35 
4           1 2024-~        5.40         0         1         15.4          1.08 
5           0 2024-~       13.3          1         1          3.27         0.885
6           1 2024-~        3.71         0         1         13.7          0.960

Over the year, this would sum to £920.88 on the Intelligent Go tariff. A further saving of £242.79.

Discussion

I can save myself £449.29, assuming that my energy use is similar in 2025 to my use in 2024. I did buy an EV in May 2024, so that may alter the total consumption, but it is only likely to tip it further in favour of Intelligent Go since I can schedule the EV charging for the cheap overnight rate. Scheduling consumption to early in the morning has the added advantage of less carbon-intensive too.¹

One thing that I haven’t modelled here is the effect of charging the batteries at the off-peak rate in the summer. In those periods, I’m probably not going to exhaust the batteries before charging starts (unless the ashp is on a Legionella cycle or a hot-water cycle) and thus a, it won’t take the full 10 kWh from the grid to reach max charge and b, I’ll start exporting to the grid a lot earlier. This is beyond what I want to spend my spare time on but means that the savings presented here are likely to be slightly underestimate the actual savings.

I love the fact that Octopus Energy have an API where I can check this sort of thing. I also love the fact that someone has been nerdy enough to write an R package to make it easy to interact with the API.

I think my analyses here are accurate, but if you spot any errors please create an issue on the github repo.

Footnotes

https://www.wwf.org.uk/challenges/green-energy-time↩︎