Web Scraping with R in 2026: Complete guide in 5 minutes

It's 2026 and your boss wants real-time competitor pricing data. Your research project needs 50,000 product reviews. Your ML model is starving for training data.

The information exists across hundreds of websites. Manually copying it would take months.

Web scraping with R lets you automate data extraction from any website. You write a script once, and it pulls exactly what you need—product names, prices, reviews, contact details—into clean data frames ready for analysis.

This guide shows you how to build production-ready scrapers in R. You'll learn techniques that work on real websites in 2026, including sites that try to block you.

What You'll Learn

• Setting up a proper R scraping environment
• Extracting data from static pages with rvest
• Handling JavaScript-heavy sites with chromote
• Scraping politely with rate limiting and robots.txt compliance
• Parallelizing scrapers for 10x speed improvements
• Bypassing common anti-bot measures
• Storing and processing your scraped data

Why R for Web Scraping in 2026?

Python dominates web scraping discussions. So why use R?

R excels when your end goal is data analysis. You scrape the data, clean it with dplyr, visualize it with ggplot2, and run statistical models—all without switching tools.

The tidyverse integration is the killer feature. You can pipe scraped data directly into your analysis workflow.

Here's a quick comparison:

Use R when you need to scrape AND analyze. Use Python when you're building large-scale production scrapers or need maximum library options.

Setting Up Your R Scraping Environment

Before writing any code, install the packages you'll need throughout this guide.

Open RStudio and run:

install.packages(c(
  "rvest",      # HTML parsing
  "httr2",      # HTTP requests (modern replacement for httr)
  "polite",     # Rate limiting and robots.txt
  "chromote",   # Headless Chrome for JavaScript sites
  "furrr",      # Parallel processing
  "dplyr",      # Data manipulation
  "purrr",      # Functional programming
  "stringr",    # String manipulation
  "jsonlite"    # JSON parsing
))

This installs the core scraping stack. Let's verify everything works:

library(rvest)
library(polite)

# Quick test - scrape the R Project homepage
session <- bow("https://www.r-project.org")
print(session)

You should see output showing the session details and robots.txt rules. If you see errors, check your R version (4.3+ recommended) and internet connection.

Scraping Static Pages with rvest

rvest is your bread and butter for static HTML pages. It wraps the xml2 and httr packages into a clean interface.

Basic Page Scraping

Let's start with a simple example. We'll scrape book titles from a test e-commerce site:

library(rvest)

# Read the HTML page
url <- "http://books.toscrape.com"
page <- read_html(url)

# Extract book titles
titles <- page %>%
  html_elements("h3 a") %>%
  html_attr("title")

# Extract prices
prices <- page %>%
  html_elements(".price_color") %>%
  html_text()

# View results
head(titles)
head(prices)

The pipe operator (%>%) chains operations together. html_elements() finds all matching nodes, while html_attr() and html_text() extract the data.

Understanding CSS Selectors

CSS selectors are how you pinpoint elements on a page. Here's a quick reference:

Use your browser's Developer Tools (F12) to inspect elements and find their selectors. Right-click any element and choose "Inspect" to see its HTML.

Extracting Tables

Many websites display data in HTML tables. rvest handles these automatically:

# Scrape a Wikipedia table
url <- "https://en.wikipedia.org/wiki/List_of_countries_by_population_(United_Nations)"

page <- read_html(url)

# Extract the first table
population_table <- page %>%
  html_element("table.wikitable") %>%
  html_table()

# View the result
head(population_table)

The html_table() function converts HTML tables directly into data frames. Clean and simple.

Handling Multiple Pages (Pagination)

Real-world scraping usually involves multiple pages. Here's how to handle pagination:

library(rvest)
library(purrr)

# Function to scrape a single page
scrape_books_page <- function(page_num) {
  url <- paste0(
    "http://books.toscrape.com/catalogue/page-",
    page_num,
    ".html"
  )
  
  page <- read_html(url)
  
  data.frame(
    title = page %>% 
      html_elements("h3 a") %>% 
      html_attr("title"),
    price = page %>% 
      html_elements(".price_color") %>% 
      html_text() %>%
      gsub("£", "", .) %>%
      as.numeric(),
    rating = page %>%
      html_elements(".star-rating") %>%
      html_attr("class") %>%
      gsub("star-rating ", "", .)
  )
}

# Scrape pages 1-5
all_books <- map_dfr(1:5, scrape_books_page)

# Check results
nrow(all_books)
head(all_books)

The map_dfr() function from purrr applies your scraping function to each page number and binds the results into one data frame.

Scraping Politely with the polite Package

Aggressive scraping can get you blocked or crash servers. The polite package enforces good behavior automatically.

Why Politeness Matters

Websites have limited server resources. Hammering them with requests can:

• Get your IP banned
• Crash their servers (potentially illegal)
• Violate their terms of service
• Make you look like a bot (which you are)

The polite package solves this by:

• Checking robots.txt before scraping
• Enforcing rate limits (default: 5 seconds between requests)
• Caching responses to avoid duplicate requests
• Identifying your scraper with a proper user agent

Basic Polite Scraping

Here's the polite workflow:

library(polite)
library(rvest)

# Introduce yourself to the host
session <- bow(
  url = "http://books.toscrape.com",
  user_agent = "Research Bot (your-email@example.com)",
  force = TRUE
)

# Check what you're allowed to scrape
print(session)

# Navigate to a specific page
page_session <- nod(session, path = "/catalogue/page-1.html")

# Scrape with automatic rate limiting
page <- scrape(page_session)

# Extract data as usual
titles <- page %>%
  html_elements("h3 a") %>%
  html_attr("title")

The bow() function establishes a session. nod() navigates within that session. scrape() fetches the page while respecting rate limits.

Scraping Multiple Pages Politely

Here's a complete example with pagination:

library(polite)
library(rvest)
library(purrr)

# Initialize session
session <- bow("http://books.toscrape.com")

# Function to scrape one page
scrape_books_polite <- function(page_num, session) {
  
  # Update path for this page
  current_page <- nod(
    session, 
    path = paste0("/catalogue/page-", page_num, ".html")
  )
  
  # Scrape (rate limiting happens automatically)
  page <- scrape(current_page)
  
  # Extract and return data
  data.frame(
    title = page %>% 
      html_elements("h3 a") %>% 
      html_attr("title"),
    price = page %>% 
      html_elements(".price_color") %>% 
      html_text() %>%
      gsub("[^0-9.]", "", .) %>%
      as.numeric()
  )
}

# Scrape 10 pages (politely!)
all_books <- map_dfr(
  1:10, 
  ~scrape_books_polite(.x, session)
)

This respects the 5-second delay between requests. For 10 pages, expect around 50 seconds total. Slower? Yes. But you won't get blocked.

Handling JavaScript-Heavy Sites with chromote

Many modern websites render content with JavaScript. When you use read_html() on these sites, you get empty results because the JavaScript never executes.

The solution is chromote—a headless Chrome browser you control from R.

Why chromote Over RSelenium?

In 2025, chromote became the recommended tool for JavaScript-heavy scraping in R. Here's why:

• Native Chrome DevTools Protocol: Direct control over Chrome without Selenium's overhead
• Better maintained: Active development by RStudio
• Simpler setup: No need for Docker or Java
• Powers rvest: The read_html_live() function in rvest uses chromote under the hood

RSelenium still works, but chromote is faster and more reliable for most use cases.

Basic chromote Usage

First, make sure you have Chrome or Chromium installed on your system.

library(chromote)
library(rvest)

# Start a new Chrome session
b <- ChromoteSession$new()

# Navigate to a page
b$Page$navigate("https://www.example.com")
b$Page$loadEventFired()

# Get the page source after JavaScript executes
html <- b$Runtime$evaluate("document.documentElement.outerHTML")$result$value

# Parse with rvest
page <- read_html(html)

# Extract data normally
titles <- page %>%
  html_elements("h1") %>%
  html_text()

# Clean up
b$close()

The key insight: chromote waits for JavaScript to execute, then gives you the final rendered HTML.

Waiting for Dynamic Content

Some sites load content asynchronously. You need to wait for specific elements:

library(chromote)

b <- ChromoteSession$new()

# Navigate to page
b$Page$navigate("https://dynamic-site.example.com")
b$Page$loadEventFired()

# Wait for specific content to appear
wait_for_element <- function(session, selector, timeout = 10) {
  start_time <- Sys.time()
  
  while (difftime(Sys.time(), start_time, units = "secs") < timeout) {
    result <- session$Runtime$evaluate(
      paste0("document.querySelector('", selector, "')")
    )
    
    if (!is.null(result$result$objectId)) {
      return(TRUE)
    }
    
    Sys.sleep(0.5)
  }
  
  return(FALSE)
}

# Wait for products to load
if (wait_for_element(b, ".product-card")) {
  # Now scrape
  html <- b$Runtime$evaluate(
    "document.documentElement.outerHTML"
  )$result$value
  
  page <- read_html(html)
  # Extract data...
}

b$close()

This function polls the page until your target element appears or timeout is reached.

Using rvest's read_html_live()

For simpler cases, rvest 1.0.4+ includes read_html_live(), which uses chromote under the hood:

library(rvest)

# This handles JavaScript automatically
page <- read_html_live("https://javascript-site.example.com")

# Extract data as usual
content <- page %>%
  html_elements(".dynamic-content") %>%
  html_text()

Much cleaner for straightforward cases. Use raw chromote when you need more control.

Parallel Scraping with furrr

Sequential scraping is slow. If you need to scrape 1,000 pages with a 1-second delay, that's 16+ minutes.

Parallel scraping runs multiple requests simultaneously across CPU cores.

Setting Up furrr

The furrr package extends purrr with parallel processing:

library(furrr)

# Set up parallel processing (use all but one core)
plan(multisession, workers = availableCores() - 1)

The multisession plan creates separate R processes. Each process can make independent HTTP requests.

Parallelizing Page Scraping

Here's a complete parallel scraping example:

library(rvest)
library(furrr)
library(purrr)

# Set up parallel processing
plan(multisession, workers = 4)

# Function to scrape one page
scrape_page <- function(page_num) {
  url <- paste0(
    "http://books.toscrape.com/catalogue/page-",
    page_num,
    ".html"
  )
  
  # Add delay to be respectful
  Sys.sleep(1)
  
  page <- read_html(url)
  
  data.frame(
    title = page %>% 
      html_elements("h3 a") %>% 
      html_attr("title"),
    price = page %>% 
      html_elements(".price_color") %>% 
      html_text() %>%
      gsub("[^0-9.]", "", .) %>%
      as.numeric(),
    page = page_num
  )
}

# Sequential version (for comparison)
system.time({
  sequential_books <- map_dfr(1:10, scrape_page)
})

# Parallel version
system.time({
  parallel_books <- future_map_dfr(
    1:10, 
    scrape_page,
    .progress = TRUE
  )
})

With 4 workers scraping simultaneously, you'll see 3-4x speed improvement.

Combining Parallel Scraping with polite

Here's the professional approach—fast AND polite:

library(polite)
library(rvest)
library(furrr)

# Set up parallel processing
plan(multisession, workers = 3)

# Initialize session
session <- bow("http://books.toscrape.com")

# Scraping function using polite
scrape_book_page <- function(page_num, session) {
  
  current_page <- nod(
    session, 
    path = paste0("/catalogue/page-", page_num, ".html")
  )
  
  page <- scrape(current_page)
  
  data.frame(
    title = page %>% 
      html_elements("h3 a") %>% 
      html_attr("title"),
    price = page %>% 
      html_elements(".price_color") %>% 
      html_text() %>%
      gsub("[^0-9.]", "", .) %>%
      as.numeric(),
    availability = page %>%
      html_elements(".availability") %>%
      html_text() %>%
      trimws(),
    rating = page %>%
      html_elements(".star-rating") %>%
      html_attr("class") %>%
      gsub("star-rating ", "", .)
  )
}

# Scrape in parallel
all_books <- future_map_dfr(
  1:50,
  ~scrape_book_page(.x, session),
  .progress = TRUE
)

# Clean up
plan(sequential)

Each parallel worker still respects rate limits, but they run concurrently.

Avoiding Blocks and Detection

Websites deploy various anti-scraping measures. Here's how to handle the common ones.

Rotating User Agents

Websites track user agents. Sending the same one repeatedly looks suspicious:

library(httr2)

# Pool of realistic user agents
user_agents <- c(
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 Safari/605.1.15",
  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36"
)

# Function to make request with random user agent
fetch_with_random_ua <- function(url) {
  ua <- sample(user_agents, 1)
  
  request(url) %>%
    req_headers("User-Agent" = ua) %>%
    req_perform() %>%
    resp_body_html()
}

Rotate user agents on each request to appear as different browsers.

Adding Realistic Headers

Real browsers send many headers. Scrapers often forget them:

library(httr2)

fetch_with_full_headers <- function(url) {
  request(url) %>%
    req_headers(
      "User-Agent" = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
      "Accept" = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
      "Accept-Language" = "en-US,en;q=0.5",
      "Accept-Encoding" = "gzip, deflate",
      "Connection" = "keep-alive",
      "Upgrade-Insecure-Requests" = "1"
    ) %>%
    req_perform() %>%
    resp_body_html()
}

Implementing Retry Logic

Networks fail. Servers return errors. Build in retry logic:

library(httr2)

fetch_with_retry <- function(url, max_retries = 3) {
  
  for (i in 1:max_retries) {
    tryCatch({
      response <- request(url) %>%
        req_timeout(30) %>%
        req_perform()
      
      if (resp_status(response) == 200) {
        return(resp_body_html(response))
      }
      
      # Rate limited - wait and retry
      if (resp_status(response) == 429) {
        wait_time <- 2^i  # Exponential backoff
        message(paste("Rate limited. Waiting", wait_time, "seconds..."))
        Sys.sleep(wait_time)
        next
      }
      
    }, error = function(e) {
      message(paste("Attempt", i, "failed:", e$message))
      Sys.sleep(2^i)
    })
  }
  
  stop("Max retries exceeded")
}

Exponential backoff (waiting longer after each failure) is the professional approach.

Using Proxies for IP Rotation

When your IP gets blocked, rotate to a different one. If you need residential proxies for serious scraping projects, providers like Roundproxies.com offer pools of rotating IPs.

Here's how to use proxies in R:

library(httr2)

# Using a proxy
fetch_with_proxy <- function(url, proxy_url) {
  request(url) %>%
    req_proxy(proxy_url) %>%
    req_perform() %>%
    resp_body_html()
}

# Example with authentication
fetch_with_auth_proxy <- function(url, proxy_host, proxy_port, username, password) {
  proxy_url <- paste0(
    "http://", username, ":", password, 
    "@", proxy_host, ":", proxy_port
  )
  
  request(url) %>%
    req_proxy(proxy_url) %>%
    req_perform() %>%
    resp_body_html()
}

Rotating proxies combined with rotating user agents makes your scraper nearly undetectable.

Handling Sessions and Cookies

Some sites require login or track sessions via cookies.

Managing Sessions with httr2

library(httr2)

# Create a session that maintains cookies
session <- request("https://httpbin.org/cookies/set/session_id/abc123") %>%
  req_cookie_preserve("cookies.txt") %>%
  req_perform()

# Subsequent requests use the same cookies
response <- request("https://httpbin.org/cookies") %>%
  req_cookie_preserve("cookies.txt") %>%
  req_perform()

print(resp_body_json(response))

Logging Into Sites

For sites requiring authentication:

library(httr2)
library(rvest)

# First, get the login page to extract any CSRF tokens
login_page <- request("https://example.com/login") %>%
  req_cookie_preserve("cookies.txt") %>%
  req_perform() %>%
  resp_body_html()

# Extract CSRF token if present
csrf_token <- login_page %>%
  html_element("input[name='csrf_token']") %>%
  html_attr("value")

# Submit login form
login_response <- request("https://example.com/login") %>%
  req_cookie_preserve("cookies.txt") %>%
  req_body_form(
    username = "your_username",
    password = "your_password",
    csrf_token = csrf_token
  ) %>%
  req_method("POST") %>%
  req_perform()

# Now scrape authenticated pages
protected_page <- request("https://example.com/dashboard") %>%
  req_cookie_preserve("cookies.txt") %>%
  req_perform() %>%
  resp_body_html()

The req_cookie_preserve() function maintains session state across requests.

Parsing and Extracting Data

Extracting Text Content

Different methods for different needs:

library(rvest)

page <- read_html("http://example.com")

# html_text() - preserves whitespace as-is
raw_text <- page %>%
  html_elements("p") %>%
  html_text()

# html_text2() - normalizes whitespace (usually what you want)
clean_text <- page %>%
  html_elements("p") %>%
  html_text2()

Use html_text2() for most cases. It handles line breaks and extra spaces better.

Extracting Attributes

# Get all link URLs
links <- page %>%
  html_elements("a") %>%
  html_attr("href")

# Get image sources
images <- page %>%
  html_elements("img") %>%
  html_attr("src")

# Get data attributes
data_ids <- page %>%
  html_elements("[data-id]") %>%
  html_attr("data-id")

Handling Relative URLs

Many sites use relative URLs. Convert them to absolute:

library(rvest)
library(urltools)

base_url <- "https://example.com"
page <- read_html(base_url)

# Get relative links
relative_links <- page %>%
  html_elements("a") %>%
  html_attr("href")

# Convert to absolute URLs
absolute_links <- url_compose(url_parse(relative_links, base_url))

# Or simpler approach
make_absolute <- function(relative, base) {
  ifelse(
    grepl("^https?://", relative),
    relative,
    paste0(base, relative)
  )
}

Cleaning Extracted Data

Real scraped data is messy. Here's a cleaning pipeline:

library(dplyr)
library(stringr)

# Raw scraped data
raw_products <- data.frame(
  title = c("  Product A  ", "Product\nB", "Product   C"),
  price = c("$19.99", "£24.50", "$15"),
  stock = c("In Stock", "Out of stock", "5 left")
)

# Clean it up
clean_products <- raw_products %>%
  mutate(
    title = str_squish(title),  # Normalize whitespace
    price = str_extract(price, "[0-9.]+") %>% as.numeric(),
    in_stock = case_when(
      str_detect(stock, "Out") ~ FALSE,
      str_detect(stock, "In Stock|left") ~ TRUE,
      TRUE ~ NA
    ),
    stock_count = str_extract(stock, "\\d+") %>% as.integer()
  )

print(clean_products)

Storing Scraped Data

Saving to CSV

# Simple CSV export
write.csv(all_books, "books_data.csv", row.names = FALSE)

# With better encoding for special characters
write.csv(
  all_books, 
  "books_data.csv", 
  row.names = FALSE, 
  fileEncoding = "UTF-8"
)

Saving to SQLite Database

For larger datasets, use a database:

library(DBI)
library(RSQLite)

# Create/connect to database
con <- dbConnect(SQLite(), "scraping_data.db")

# Write data
dbWriteTable(con, "books", all_books, overwrite = TRUE)

# Query it later
results <- dbGetQuery(con, "SELECT * FROM books WHERE price < 20")

# Close connection
dbDisconnect(con)

Incremental Scraping

For ongoing projects, only scrape new content:

library(DBI)
library(RSQLite)

scrape_new_items <- function(all_urls) {
  con <- dbConnect(SQLite(), "scraping_data.db")
  
  # Get already scraped URLs
  existing <- dbGetQuery(con, "SELECT url FROM items")$url
  
  # Find new URLs
  new_urls <- setdiff(all_urls, existing)
  
  if (length(new_urls) == 0) {
    message("No new items to scrape")
    dbDisconnect(con)
    return(NULL)
  }
  
  # Scrape only new items
  new_data <- map_dfr(new_urls, scrape_single_item)
  
  # Append to database
  dbWriteTable(con, "items", new_data, append = TRUE)
  
  dbDisconnect(con)
  return(new_data)
}

Real-World Example: Building a Price Monitor

Let's put everything together with a practical project—a price monitoring scraper:

library(rvest)
library(polite)
library(dplyr)
library(furrr)
library(DBI)
library(RSQLite)

# Configuration
config <- list(
  base_url = "http://books.toscrape.com",
  pages_to_scrape = 50,
  parallel_workers = 3,
  db_file = "price_monitor.db"
)

# Initialize session
session <- bow(
  url = config$base_url,
  user_agent = "PriceMonitor/1.0 (research@example.com)"
)

# Scraping function
scrape_page <- function(page_num, session) {
  current_page <- nod(
    session, 
    path = paste0("/catalogue/page-", page_num, ".html")
  )
  
  page <- scrape(current_page)
  
  data.frame(
    title = page %>% 
      html_elements("h3 a") %>% 
      html_attr("title"),
    price = page %>% 
      html_elements(".price_color") %>% 
      html_text() %>%
      gsub("[^0-9.]", "", .) %>%
      as.numeric(),
    url = page %>%
      html_elements("h3 a") %>%
      html_attr("href") %>%
      paste0(config$base_url, "/catalogue/", .),
    scraped_at = Sys.time()
  )
}

# Run scraper
plan(multisession, workers = config$parallel_workers)

message("Starting scrape...")
start_time <- Sys.time()

all_products <- future_map_dfr(
  1:config$pages_to_scrape,
  ~scrape_page(.x, session),
  .progress = TRUE
)

end_time <- Sys.time()
message(paste("Scraped", nrow(all_products), "products in", 
              round(difftime(end_time, start_time, units = "mins"), 2), "minutes"))

# Store results
con <- dbConnect(SQLite(), config$db_file)
dbWriteTable(con, "prices", all_products, append = TRUE)

# Quick analysis
price_stats <- all_products %>%
  summarise(
    total_products = n(),
    avg_price = mean(price),
    min_price = min(price),
    max_price = max(price)
  )

print(price_stats)

dbDisconnect(con)
plan(sequential)

This script is production-ready. It's polite, parallel, and stores results incrementally.

Common Errors and How to Fix Them

"Error: HTTP error 403"

The server blocked you. Solutions:

1. Add realistic headers (especially User-Agent)
2. Slow down your requests
3. Use a proxy
4. Check if the site requires JavaScript rendering

"Error: HTTP error 429"

Rate limited. Solutions:

1. Implement exponential backoff
2. Increase delay between requests
3. Use the polite package

"Error: Timeout was reached"

Server too slow or overloaded:

# Increase timeout
request(url) %>%
  req_timeout(60) %>%  # 60 seconds
  req_perform()

"Empty Results" from JavaScript Sites

Content loads via JavaScript:

# Use chromote instead of read_html
library(chromote)
b <- ChromoteSession$new()
b$Page$navigate(url)
b$Page$loadEventFired()
Sys.sleep(3)  # Wait for JS
html <- b$Runtime$evaluate("document.documentElement.outerHTML")$result$value
page <- read_html(html)
b$close()

Ethical Scraping Guidelines

Web scraping sits in a legal gray area. Follow these principles:

1. Check robots.txt first. If it says "Disallow", don't scrape that path.
2. Read Terms of Service. Some sites explicitly prohibit scraping.
3. Don't overload servers. One request per second is a good baseline.
4. Identify yourself. Use a descriptive user agent with contact info.
5. Respect rate limits. If you get 429 errors, slow down.
6. Don't scrape personal data without proper legal basis (GDPR, CCPA).
7. Cache aggressively. Don't re-download the same page.
8. Consider the impact. Would your scraping harm the site's business?

Wrapping Up

Web scraping with R is a powerful skill for data professionals. You've learned:

• Basic scraping with rvest for static pages
• Polite scraping with automatic rate limiting
• JavaScript rendering with chromote
• Parallel processing for speed
• Anti-detection techniques
• Data storage and cleaning

Start simple with rvest. Add polite for any serious project. Bring in chromote when you hit JavaScript-heavy sites. Parallelize with furrr when speed matters.

Most importantly—be respectful. Scraping is a privilege, not a right. Sites that get hammered by scrapers often implement aggressive blocking that hurts everyone.

The techniques in this guide work for 90% of scraping projects. For the remaining 10%—CAPTCHAs, sophisticated anti-bot systems, complex authentication—you'll need specialized solutions beyond this guide's scope.

Now go scrape responsibly.