How to Scrape Tables with Beautifulsoup?

Tables are one of the most common elements you'll want to scrape from websites. Whether it's an HTML table displaying financial data, sports statistics, or product information, BeautifulSoup makes it easy to locate, parse, and extract tables into structured Python data.

In this comprehensive guide, you'll learn step-by-step how to scrape tables using Python and the BeautifulSoup library.

Why Table Scraping is So Valuable

Many websites display important data in HTML tables. Some examples include:

  • Financial data – stock prices, exchange rates, interest rates
  • Sports stats – player stats, league standings, box scores
  • Product info – pricing, features, comparisons
  • Geographic data – demographics, transportation stats
  • Scientific data – medical, biology, chemistry data

This information is often available publicly but locked away in tables on webpages rather than offered through APIs or downloads. Scraping these HTML tables provides a way to unlock this useful data. After extracting the table contents, it can be loaded into DataFrames or databases for further analysis using Python, SQL, or other languages.

Some common applications of scraped table data include:

  • Populating pricing comparison sites
  • Compiling company/industry market intelligence
  • Analyzing sports analytics and building models
  • Gathering demographic statistics
  • Conducting scientific research

The first step for any of these use cases is extracting the underlying HTML tables from websites. BeautifulSoup provides simple tools for locating, parsing, and extracting tabular data from page contents.

Now let's look at how to install and use BeautifulSoup for table extraction.

Installing and Importing BeautifulSoup

BeautifulSoup can be installed via pip:

pip install beautifulsoup4

Or via conda:

conda install -c anaconda beautifulsoup4

Once installed, we import it:

from bs4 import BeautifulSoup

BeautifulSoup takes HTML and converts it into a nested Python object based on the page structure. We can then use it to navigate and search the document. BeautifulSoup works with both HTML and XML documents. Under the hood it uses a parser like lxml or Python's built-in html.parser to process and traverse the page contents.

We'll also need the requests module to retrieve the page for scraping:

import requests

Let's look at a quick example:

import requests
from bs4 import BeautifulSoup

page = requests.get("")
soup = BeautifulSoup(page.content, 'html.parser')

# <title>Example Domain</title>

This fetches the content, passes it to BeautifulSoup, and prints the <title> element text. BeautifulSoup makes it easy to search, navigate, and manipulate HTML and XML documents. With just the basics down, let's look at techniques for locating and extracting tables.

Locating Table Elements

The first step is to locate the <table> element(s) we want to extract. The simplest approach is using the find() method. For example:

table = soup.find('table')

This will find the first table on the page. We can also search by attributes like id or class:

financials_table = soup.find('table', id='financials')
product_tables = soup.find_all('table', class_='product-listing')

Other common attributes to search for include:

  • data-table=
  • role="table"
  • aria-label=

Or we can combine attributes:

stats_table = soup.find('table', {'id': 'stats', 'class': 'sortable'})

If there are multiple tables we want, use find_all() instead:

tables = soup.find_all('table')

This will return a list of all <table> elements on the page that we can iterate through. Let's look at some specific examples:

Example: Locate Table by ID

For this example HTML:

<table id="data">

We can locate it with:

table = soup.find('table', id='data')

Example: Locate By Class Name


<table class="population">


table = soup.find('table', class_='population')

Example: Locate All Tables

For a page with multiple tables like:



We can get a list of all tables with:

tables = soup.find_all('table')

The find and find_all methods allow us to hone in on the exact table elements we want to extract. Now let's look at techniques for iterating through the table data.

Looping Through Table Rows

Once we've isolated the <table> element, we can loop through its rows to extract the data. The row elements in an HTML table are <tr> tags. We'll first find all rows:

rows = table.find_all('tr')

Then loop through the rows:

for row in rows:
   # extract data from each row

Inside this loop we can now work on extracting the cell contents from each row. Let's look at some examples.

Example: Iterate through Rows

Given a simple table:

   <td>Row 1, Cell 1</td>
   <td>Row 1, Cell 2</td>
   <td>Row 2, Cell 1</td>  
   <td>Row 2, Cell 2</td>

We can loop through rows like:

table = soup.find('table')

for row in table.find_all('tr'):
    # <tr>...</tr>
    # <tr>...</tr>

This allows us to isolate each row element for further extraction.

Nested Loop Through Cells

We can add another loop to also iterate through the cells:

for row in table.find_all('tr'):
    cells = row.find_all('td')
    for cell in cells:
        # <td>Row 1, Cell 1</td>
        # <td>Row 1, Cell 2</td> 
        # <td>Row 2, Cell 1</td>
        # <td>Row 2, Cell 2</td>

This double loop structure is common for iterating through table data. Now let's extract the text and values.

Extracting Cell Data

Within each row we want to extract the text or numeric values from the table cells. Table data is contained within <td> tags for standard cells and <th> tags for header cells. We can find these cells using .find_all():

cells = row.find_all(['td', 'th'])

Then loop through the cells and call .text to extract the inner content:

for cell in cells:
    cell_text = cell.text

Let's look at some more specific examples.

Example: Extracting Text



We can extract the text:

cells = row.find_all('td')

for cell in cells:
# Apple
# Banana

Example: Extracting Numbers

Table data may also contain numbers:


The extraction is the same:

for cell in cells:
# 10  
# 20

But we may want to convert them to integers:

for cell in cells:
    cell_text = int(cell.text)

This gives us the numeric values.

Storing Cell Data

Rather than printing the cell text, we'll usually want to store the results in variables or data structures. For example, storing in lists:

row_data = [] 

for cell in row.find_all("td"):
    cell_text = cell.text.strip() 

This gives us a list containing the cell text for an entire row. Do this for every row, and we get a list of lists containing all the table data. There are also additional techniques we can use like handling headers, data cleansing, and more – let's explore those next.

Handling Multiple Tables

Larger pages may contain several table elements. To handle these, use find_all() which will return a list:

tables = soup.find_all('table')

We can then iterate through the tables:

for table in tables:
    # extract data from each table

Or access a specific table via index:

first_table = tables[0]
second_table = tables[1]

If we need a particular table, we can scan through and find it:

for table in tables:
    if 'id="users"' in str(table):
        users_table = table

This allows us to isolate the exact table(s) we need to extract.

Data Cleansing Techniques

After extracting cell text, we may want to clean it up before further processing. Some useful techniques include:

Strip Whitespace

Remove extra whitespace from cell text:

cell_text = cell.text.strip()

Remove HTML Tags

Get only the text without HTML tags:

cell_text = cell.get_text()

Handle Numeric Data

Convert numbers to proper types:

value = int(cell.text) 

value = float(cell.text)

Concat Values

If a cell value spans multiple tags:


We can concatenate the pieces:

cell_text = ''

for elem in cell.contents:
  cell_text += elem.text.strip()
# Price $9.99

These cleansing techniques help prepare clean, structured data for loading into DataFrames or storage.

Converting to DataFrames

After extracting the cell data, it's useful to convert it into a pandas DataFrame for further analysis and processing. We can pass the list of rows along with a list of headers into the DataFrame constructor:

import pandas as pd

rows = # scraped data
headers = # scraped headers

df = pd.DataFrame(rows, columns=headers)

Now we have a nicely formatted DataFrame representing the HTML table. Some examples of using DataFrames:

  • View and analyze data
  • Sort, filter, count rows/columns
  • Export to CSV
  • Generate reports
  • Feed into machine learning

Let's look at an example:

Example: Table to DataFrame

For this table data:


We can extract it into lists:

headers = ['Name', 'Age']
rows = [
    ['John', 30],
    ['Sarah', 25]

And convert to a DataFrame:

import pandas as pd

df = pd.DataFrame(rows, columns=headers)


  Name  Age
0  John   30
1  Sarah  25

This provides a foundation for further data analysis.

Dealing with Common Scraping Issues

There are some common challenges that arise when scraping HTML tables such as:

Nested Column Headers

Table headers may be nested like:


We'll need custom logic to extract these properly.

Row Spanning Multiple Tags

Rows may be split across multiple tags:

   <td>Cell 1</td>
   <td rowspan="2">Cell 2</td>
   <td>Cell 3</td>

Again requiring custom extraction code.

Dynamic JavaScript Rendering

The raw HTML may not contain the full table. It could be generated dynamically with JavaScript. In these cases, additional libraries like Selenium may be needed to render the full data.

Large Tables

Performance and memory issues arise on extremely large tables. This may require chunking or optimization. While not always straightforward, these issues can be handled with specialized parsing code and algorithms.

Table Scraping Tips and Tricks

Here are some additional tips for success when scraping tables:

  • Inspect carefully – Thoroughly examine the page structure using developer tools before writing your scraper.
  • Locate precisely – Utilize ids, classes, attributes and CSS selectors to hone in on the right table(s).
  • Handle edge cases – Account for multi-level headers, colspan/rowspans, nested HTML, etc.
  • Clean as you go – Trim, convert types, handle missing data, etc. as part of the extraction loop.
  • Convert early – Place extracted data into dictionaries, DataFrames, etc. for easier manipulation.
  • Store incrementally – For large tables, store data in chunks rather than all at once.
  • Test rigorously – Unit test your scrapers thoroughly to catch edge cases.
  • Debug liberally – Employ print statements and breakpoints to inspect interim data.
  • Document carefully – Comment your code clearly to capture assumptions and nuances.

Following best practices like these will lead to robust, maintainable scrapers.

Scraping Tables into DataFrames – Full Example

Here is a full script putting together all the main steps covered: locating the table, extracting rows and cells, cleansing the data, and converting into a pandas DataFrame:

import requests
from bs4 import BeautifulSoup
import pandas as pd

url = ""

# Get HTML and init BeautifulSoup
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser') 

# Find the table 
table = soup.find('table', id='data')

# Extract headers
headers = []
for i, th in enumerate(table.find("tr").find_all("th")):
# Extract table data    
rows = []
for i, tr in enumerate(table.find_all("tr")[1:]):
    cells = []
    # Extract cells 
    for td in tr.find_all(["td", "th"]):
# Convert to DataFrame   
df = pd.DataFrame(rows, columns=headers)


This provides a template for scraping data locked away in HTML tables into easy-to-use DataFrames using Python!

BeautifulSoup makes extracting table data simple. Some key takeaways:

  • Use find() or find_all() to locate <table> elements
  • Iterate through <tr> row elements
  • Extract <td> and <th> cell text values
  • Store in row/cell nested lists
  • Optional – Convert to pandas DataFrame for analysis

Scraping tables unlocks a wealth of data for analytics, reporting, visualizations, and more. I hope this guide provides a solid foundation for using BeautifulSoup to extract tables in your own projects! Let me know in the comments if you have any other tips or questions.

John Rooney

John Rooney

John Watson Rooney, a self-taught Python developer and content creator with a focus on web scraping, APIs, and automation. I love sharing my knowledge and expertise through my YouTube channel, My channel caters to all levels of developers, from beginners looking to get started in web scraping to experienced programmers seeking to advance their skills with modern techniques. I have worked in the e-commerce sector for many years, gaining extensive real-world experience in data handling, API integrations, and project management. I am passionate about teaching others and simplifying complex concepts to make them more accessible to a wider audience. In addition to my YouTube channel, I also maintain a personal website where I share my coding projects and other related content.

We will be happy to hear your thoughts

      Leave a reply

      Compare items
      • Total (0)