Using cookiemonster

# Using `cookiemonster`

## Reading and storing cookies

Welcome to the `cookiemonster` package, a one-stop solution to help you navigate the delicious world of browser cookies! In this vignette, we will explain what browser cookies are, how to read and store them using the `cookiemonster` package, and interact with them using the modern `httr2` package, the legacy `httr` package, and the powerful `curl` package.

## What are Browser Cookies?

This package helps you manage browser cookies in R, making it easy to work with cookies when sending HTTP requests. Before we dive into the functions and features of the package, let’s briefly discuss what browser cookies are. Browser cookies are small pieces of data that websites send to your browser to store and later retrieve. They help websites remember your preferences, login information, or even the items in your shopping cart. Cookies play a crucial role in making your browsing experience smooth and personalized. In `R` browser cookies come in handy when working with tasks that involve web interactions, like web scraping, browsing automation, website testing, or API calls that require authentication. They allow your scripts to efficiently mimic browser behaviour and maintain sessions as well as user-specific data.

## Reading and Storing Cookies

Using the `cookiemonster` package, we can easily read and store cookies for further use. First, let’s load the package:

    library(cookiemonster)

To use cookies with the `cookiemonster`, you will need to export the necessary cookies from your browser after visiting or logging into a website. To do this, you can use browser extensions like “Get cookies.txt” for Chromium-based browsers or “cookies.txt” for Firefox.

Let’s import an example cookie file provided by the `cookiemonster` package:

    file.copy(
      from = system.file("extdata", "cookies.txt", package = "cookiemonster"),
      to = "."
    )

This is how the file looks like:

    readLines("cookies.txt") |>
      cat(sep = "\n")

    #> # Netscape HTTP Cookie File
    #> # http://curl.haxx.se/rfc/cookie_spec.html
    #> # This is a generated file!  Do not edit.
    #>
    #> hb.cran.dev  FALSE   /   FALSE   Inf test    true
    #> hb.cran.dev  FALSE   /   FALSE   Inf cookies allow
    #> hb.cran.dev  FALSE   /   FALSE   Inf easy    true

Now, let’s add the cookies from this file to our cookie jar:

    add_cookies(cookiefile = "cookies.txt")

You can also import cookies directly from your browser (only works with Firefox at the moment):

    cookies <- get_cookies_from_browser(browser = "Firefox")
    store_cookies(cookies)

If you are working with `rvest` version 1.0.4 or above, you might also know about live browser sessions:

    sess <- rvest::read_html_live("https://vu.nl")

You can actually open a browser using `sess$view()`. To save the cookies from this session, e.g., after logging in on a website, simply run:

    add_cookies(session = sess)
    #> ✔ Cookies for vu.nl put in the jar!

## Default Cookie Storage

The `cookiemonster` package stores cookies in a default location. To see this location, you can use:

    default_jar()
    #> [1] "~/.cache/r_cookies"

If you want to change the default cookie storage location, you can set the `cookie_dir` option:

    options(cookie_dir = tempdir())
    default_jar()
    #> [1] "/tmp/Rtmpw4pjnd"

To revert back to the original cookie storage location:

    options(cookie_dir = NULL)
    default_jar()
    #> [1] "~/.cache/r_cookies"

To retrieve cookies for a specific domain:

    get_cookies("hb.cran.dev")
    #> # A tibble: 3 × 7
    #>   domain      flag  path  secure expiration name    value
    #>   <chr>       <lgl> <chr> <lgl>  <dttm>     <chr>   <chr>
    #> 1 hb.cran.dev FALSE /     FALSE  Inf        test    true
    #> 2 hb.cran.dev FALSE /     FALSE  Inf        cookies allow
    #> 3 hb.cran.dev FALSE /     FALSE  Inf        easy    true

Note that his function uses regular expressions to match the domain by default.

## Using `cookiemonster` with other packages

### Using Stored Cookies with `httr2`

Now let’s see how to use stored cookies with the `httr2` package:

    library(httr2)
    resp <- request("https://hb.cran.dev/cookies/set") |> # start a request
      req_options(cookie = get_cookies("hb.cran.dev", as = "string")) |> # add cookies to be sent with it
      req_perform() # perform the request

    resp |>
      resp_body_json()
    #> $cookies
    #> $cookies$cookies
    #> [1] "allow"
    #>
    #> $cookies$easy
    #> [1] "true"
    #>
    #> $cookies$test
    #> [1] "true"

For convenience, there is also a shorthand that automatically uses all cookies for the domain in the `request`:

    resp <- request("https://hb.cran.dev/cookies/set") |> # start a request
      req_cookiemonster_set() |> # add cookies to be sent with it
      req_perform() # perform the request

    resp |>
      resp_body_json()
    #> $cookies
    #> $cookies$cookies
    #> [1] "allow"
    #>
    #> $cookies$easy
    #> [1] "true"
    #>
    #> $cookies$test
    #> [1] "true"

As you can see, the individual cookie values we see above are returned correctly. This is because the server at https://hb.cran.dev is configured to echo requests send to it. It shows us that the correct cookies were send (hooray!).

### Using Stored Cookies with `httr`

To use stored cookies with the legacy `httr` package:

    library(httr)
    GET("https://hb.cran.dev/cookies/set", set_cookies(get_cookies("hb.cran.dev", as = "vector")))
    #> Response [https://hb.cran.dev/cookies]
    #>   Date: 2025-11-29 21:35
    #>   Status: 200
    #>   Content-Type: application/json
    #>   Size: 88 B
    #> {
    #>   "cookies": {
    #>     "cookies": "allow",
    #>     "easy": "true",
    #>     "test": "true"
    #>   }
    #> }

This code uses the ‘httr’ library to set cookies from the ‘https://hb.cran.dev’ website (a test website for development). The `GET` function is used to set the cookies, and the `set_cookies` function add cookies to the request.

### Using Stored Cookies with `curl`

`curl` is the backbone of both `httr` and `httr2`, which provide a more straightforward interface for it. You can also use `curl` directly though (which is only recommended for advanced users though). To make the same request as above, we can use this code:

    library(curl)
    h <- new_handle()
    handle_setopt(h, cookie = get_cookies("hb.cran.dev", as = "string"))
    resp <- curl_fetch_memory("https://hb.cran.dev/cookies/set", handle = h)
    jsonlite::fromJSON(rawToChar(resp$content))
    #> $cookies
    #> $cookies$cookies
    #> [1] "allow"
    #>
    #> $cookies$easy
    #> [1] "true"
    #>
    #> $cookies$test
    #> [1] "true"

If the `curl` response contains new cookies:

    h2 <- new_handle()
    resp <- curl_fetch_memory("https://hb.cran.dev/cookies/set?new_cookies=moo", handle = h2)
    handle_cookies(h2)
    #>        domain  flag path secure expiration        name value
    #> 1 hb.cran.dev FALSE    /  FALSE        Inf new_cookies   moo

Use `store_cookies` to store them in your jar:

    new_cookies <- handle_cookies(h2)
    store_cookies(new_cookies)
    get_cookies("hb.cran.dev")
    #> # A tibble: 1 × 7
    #>   domain      flag  path  secure expiration name        value
    #>   <chr>       <lgl> <chr> <lgl>  <dttm>     <chr>       <chr>
    #> 1 hb.cran.dev FALSE /     FALSE  Inf        new_cookies moo

Keep in mind that adding cookies for a domain will replace all previously stored cookies for that domain by default.

Now that you have an understanding of how the `cookiemonster` package can be used with `httr2`, `httr`, and `curl`, you’re ready to take control of browser cookies in your R projects! Happy coding and stay sharp, cookie monsters!