---
title: 'Advanced Web Scraping Tutorial! (w/ Python Beautiful Soup Library)'
source: 'https://youtube.com/watch?v=DcI_AZqfZVc'
video_id: 'DcI_AZqfZVc'
date: 2026-06-15
duration_sec: 0
---

# Advanced Web Scraping Tutorial! (w/ Python Beautiful Soup Library)

> Source: [Advanced Web Scraping Tutorial! (w/ Python Beautiful Soup Library)](https://youtube.com/watch?v=DcI_AZqfZVc)

## Summary

This tutorial demonstrates advanced web scraping techniques using Python and Beautiful Soup, focusing on scraping product data from Walmart.com. The video covers extracting data from JavaScript-rendered pages, handling anti-scraping measures, and using proxy networks to avoid IP blocks.

### Key Points

- **Introduction and Sponsor** [00:00] — The video covers advanced web scraping with Python. Sponsor Bright Data offers proxy tools and datasets.
- **Inspecting Walmart Page** [01:30] — Right-click and inspect HTML to find data. Walmart uses 'next data' script tag containing a JSON object with page props.
- **Fetching Page with Headers** [06:00] — Use requests library with custom headers (User-Agent, Accept-Language) to mimic a real browser and avoid being blocked.
- **Parsing JSON Data** [09:00] — Extract the script tag with id 'next data', parse JSON, and navigate nested keys to find product price and review info.
- **Using LLMs to Parse JSON** [14:00] — Large language models like Claude can help identify important fields in large JSON objects.
- **Building Scraper Functions** [15:00] — Create two functions: extract_product_info (given a product URL) and get_product_links (given a search query and page number).
- **Looping Through Pages** [20:00] — Loop over search result pages, collect product links, and extract info for each product, saving to a JSON lines file.
- **Handling Duplicates and Multiple Queries** [24:00] — Improve scraper by tracking seen URLs to avoid duplicates and support multiple search queries.
- **IP Blocking and Bright Data Proxy** [27:00] — Walmart blocks IP after many requests. Bright Data proxy network provides multiple IPs to avoid blocks.
- **Implementing Proxy in Code** [33:00] — Use environment variables for proxy credentials and pass proxies parameter in requests.get to rotate IPs.
- **Error Handling and Retries** [37:00] — Add retry logic with backoff to handle proxy failures gracefully.
- **Next Steps: Selenium** [39:00] — For dynamic content, use Selenium with Bright Data scraping browser to bypass CAPTCHAs.

### Conclusion

This tutorial provides a solid foundation for advanced web scraping, including handling JavaScript-rendered data, using proxies to avoid IP blocks, and scaling up with multiple search queries. The next step is to explore Selenium for dynamic content and CAPTCHA bypass.

## Transcript

hey what's up everyone welcome back to
another video in this video we are going
to do some Advanced web scraping with
python if you haven't already seen it I
recommend checking out my overview on
the python beautiful soup Library I'll
pop it up right here but this is going
to kind of take that video and really
build onto more advanced things that you
might see in the wild web scraping is a
incredibly useful skill I do a lot of
work on upwork and I feel like the most
common thing that I ever see is web
scraping jobs so if you can Master web
scraping you have tons of opportunities
when it comes to freelance when it comes
to work etc before we get into the video
though I want to give a shout out to
this video sponsor and that is bright
data when it comes to really Advanced
web scraping stuff it's hard to do it on
your own one of the things that I like
most about bright data our sponsor is
they offer all sorts of proxy tools
which basically allows you to send
requests from many different locations
and it bypasses it allows you to
ultimately bypass a lot of the
restrictions that sites try to implement
to prevent you from scraping them uh if
you don't want to deal with learning how
to web scrape and watching this whole
tutorial bright data also offers a bunch
of data sents that are available for
purchase such as Walmart which we'll be
scraping today but also Amazon
Airbnb Instagram LinkedIn Etc so tons of
data sets in the data set Marketplace
that you could also just get started
super quickly but without further Ado
let's get into this tutorial all right
to demonstrate these Advanced scraping
techniques we're going to be doing some
scraping on walmart.com and if this ever
feels too quick for you I recommend
checking out the original video I did on
uh beautiful soup which will be linked
in the description and also I'll pop it
up right here the first thing we'll want
to do with any sort of web scraping
project is kind of identify the HTML of
what we're trying to scrape so let's say
I was looking for a new computer monitor
because of course I'm a programmer I
need 10,000 monitors at all times time
so I look up monitor here and let's see
what looks good let's click on this
first Samsung one how about this Odyssey
G6 we'll check that out so if I was
trying to web scrape and like collect
information because I want to pay the
best price for these monitors uh I'm
going to be looking at the HTML on the
page so I might be trying to get this
information I might be able to you know
trying to get the you save information
probably be trying to get this
information maybe the reviews
information bunch of things that I want
to get but the way that we do this in
web scraping land is you for most
internet browsers you can write click
and click on inspect which opens up the
kind of HTML source code so if we look
in here we can specifically click
inspect on this tag and kind of find
where the price is one thing though that
I also notice with this specific Walmart
page is there's this concept of item
props so that kind of leads me to to
think that maybe there's another kind of
technique going on here that's getting
some of this information if we look at
all of the information on this page
trying to see if there's anything that
sticks out here yep there we go um
there's this next data field let's see
what's in that uh and we see in here
there's this massive massive Json object
that has props so this next data tag is
telling me this is a specific type of
JavaScript project
that leverages these props and passes
them in on the web page so instead of
actually scraping from the HTML tags
themselves we can actually usually find
the information we're looking for within
this props
field um so I think kind of our
technique for scraping information from
Walmart will be do a search like we just
did so we had you know the search for
monitor this is a pretty easy format I
could very easily replace monitor here
with other words and search for them
and then kind of programmatically go
through this page maybe click on items
and then once we're clicking on an
item we'll see for this monitor too that
it also has these page props and then in
this page props
information basically we'll want to look
for and find where the actual price is
within this nested Json so that's the
general technique Let's uh open up a
code code editor and kind of just write
some template code out to help us do
this so I'm in this Advanced scraping
repo and I'll link this in the
description uh I'll link my GitHub repo
with all the code that we'll see in this
video but I'll just call this like
Walmart
scraper
dopy and probably the first thing we'll
want to do is install beautiful soup and
I recommend if um you know how to to set
up a virtual environment to do this I'll
link a video on how to do that right
here but we can go pip 3 install
beautiful soup 4 we see we already have
it and we're also going to want to use
the requests Library so I'll just kind
of template out some code and then kind
of explain it more in depth in a
sec often like when I forget how to
import things feel like beautiful soup
is always a weird thing I like using
Copilot
and then I also want to import the
requests library and Walmart URL equals
how about
https
walmart.com SL maybe we grab a specific
one of those pages that we had
open so I'm just going to steal this
page real quick that URL is this so just
take any product URL from Walmart we got
the curved Ultra wide Monitor and then
we'll want to get that so
response equals requests.get pass in a
URL and we'll print out that
HTML okay so let's go ahead and do that
cool we get the
HTML and the next thing we'll want to do
is get specifically that next data tag
so we can start looking at what's in
that so if we look at our web page again
I inspect this
this next data basically we'll want to
find the script with the ID next data so
how do we do that with beautiful soup so
we'll say soup
equals beautiful soup response. text
we'll use the HTML
parser and we'll specifically want to
find that sup tag with the ID
so sup find script tag with idid
next data I think it was like this we
can change the ID if we have to that
looks good basically we want to just
print out the HTML again and it says
None that is strange why does it say
none so let's make sure that the next
data is correct next 22
underscores so that looks correct and so
this is the first I think like Advanced
feature that you'll have to know about
if you ever have a situation where you
retrieve a page it's usually one or two
and like the tag you're looking for is
not there when you retrieve it with
python it's e either one of two things
one is that this is a dynamic page that
like some of the stuff loads a little
bit later or two they're purposely
hiding stuff from from requests that
don't look Human by default there's
certain headers when you use the
requests library in Python and so to get
around and make ourselves look more
human we want to make sure that that we
mock whatever headers we use when we're
actually making this request in the
python land what I would probably do
here to figure out what are good headers
to use look at our Network and any
really one of these probably will be
fine and basically we want to just copy
the headers that we use in our actual
web browser so we have the request
headers down here we copy some of these
parameters we'll probably find we have
more success so we probably want to copy
the accept languages and the user agent
tags good and sometimes you might even
want to like have this cycle between
several different options so you always
are changing up what you look like We'll
add
commas that looks good cool and so now
what we can do with our requests library
and I guess I have to change the order
of this slightly
we can pass in the
headers equals the new headers that
we've added and now the question is can
we find this script tag so we're going
to go ahead and run all of this
code and look at that we do get um this
next data field that we are looking for
awesome all right now that we have this
data here we want to be able to grab
specifically the price from this so what
I would recommend is this is
crazy uh complicated to look at I feel
like probably it's purposely like just
super OB obis skated to make it hard to
grab everything what I might do is go
back to the web page inspect grab the
next data I might copy the element and
then what I might recommend do is doing
is copy this Json go to like a online
token counter probably a bunch of these
will work I'm just going to use this
streamlet app I see and paste in your
Json and then see how many tokens so we
see we have like 59,000 tokens not super
friendly to honestly the like GPT 3.5 I
think that's above any limits it can
process you could use GPT 4 if you have
access to full
128k context basically the goal is can
we look at what's in this without having
to to dig through all of this Json
couple different ways to do it um what
we might do real quick and we'll want to
make this Json so we can do that by
importing the Json Library as
well and then we can go ahead and we
should be able to do something like um
data
equals HTML or script
tag. string that'll get all the text
within it we can do json. loads
and now we should be able to print out
data. Keys cool look at that
so basically we can kind of keep
repeating this process we could get the
props and then see what the keys of that
are it's going to be kind of a slow
process but I'm just kind of showing how
you could do it
manually so what are the props of the
keys or the keys of the props page props
so we know we have to go into page props
and I'm thinking they're in props just
because that's what you know the
JavaScript framework will
leverage uh initial data sounds pretty
good I would say probably
data not
headers um probably product
but maybe also review information would
be helpful
too oh wow now there's a lot of things
now I'd look at if there's a price in
here somewhere
price do we see any
price price info I like
that now what's in the price info
one current price I like that this might
be the end of our
dictionary we'll
see and then I think probably if we get
price from
this see what we get look at that that
gives us $199 and if we look at the
product that we were looking at it is
100% $199 so that was getting
information from this page not super
easy but uh the reason I was asking
saying go to this token counter is
if you have a large language model that
has the ability to parse this number of
tokens what I might recommend is copying
your code like for example Claude if you
have the pro
version um Can parse a lot so I might
say what are the most important
fields from the following
Json to get the price info and review
info for the current
product paste this in which is crazy
very long um I'd say limit to just
10 uh
items share full path to get to that
field using python syntax or something
like that
this looks like pretty
good um I noticed that it's just going
like four levels deep so I feel like
it's skipped over the stuff to get to
product um I might say hey wait to get
to product you need to use the following
path here's the code I found that works
for
price please adjust Solutions
accordingly copy this paste it
in perfect this looks useful so take
this as an example but you can use like
large language models to help you parse
you know massive amounts of Json like
this but to simplify the process if you
go to the GitHub link I'll share some a
code stimp it that will help us get the
information we're looking for so I'll go
ahead and paste that in here we go so
here's a nice little product info
dictionary and I can go ahead and print
product
info for our current product look at
that review count 239 let's check to see
if that's also valid look at that 239
reviews so this looks great we're
getting some information I think the big
thing though is if we wanted to collect
a lot of information on products such as
you know these monitors and collect it
over time and you know every day maybe
run something that gets all this
information and it stores it in a
database or something we need to modify
this a bit so what might we do well we
can separate this into maybe two
functions one function will be called
extract product
info that will take in some sort of
product URL and we can basically just
paste in what we already
have so this is product URL now and
instead of printing product info we'll
return product info so that's one of our
functions and then the other function we
might want to have is like get uh
product
pages or get product links or something
like
that and what that might look like is
maybe that takes in a a query if you
remember how we got to this monitor page
the first thing we did was we did a
search that looks like this so I'm going
to go ahead and copy this call this like
base URL or like search URL Hub out
search URL equals this and then we can
use an F string to F flip out the search
term and make that whatever our query is
I think the only other thing I might add
to this is let's say we wanted to scrape
a bunch of infation
on
monitors well this is all the monitors
but you know what if we wanted more than
just the first page of monitors we might
go to the second page and we see that
you can also leverage Page information
here so I'm going to go ahead and copy
that and put this also into my URL so
how about we also pass in a page
number and by default it can start at
one you want to do a similar type thing
get all of the pages or get get this
search URL then we would probably want
to get all of the links from this so if
I look at this page right click
inspect we get this href here looks like
this um these is are sponsored ones
scroll out these first ones are all
sponsored so I might just see what it
looks like if it looks any different on
non-sponsored ones okay here's another
link it's and this look at that it's
just a a doesn't have the full URL just
has the kind of this part of it so we
want to be able to handle both cases so
grabbing all of those links might look
something
like basically we want to find all the
links in this so
find all a
tags I want to make sure that they have
an
href as part of it because that's how
we're going to access this
information and then we can do something
like
for for
Link in links and then we know that the
product URLs I think one little trick
always have this slash I them so what I
might do to grab all the links and not
get anything that's like a link to some
other random
page um that's not super useful is I
might check to see if in the text so if
this specific term is in the in link hre
href is the actual link stuff so that's
why we're looking at that specifically
and we basically want to add that link
to some sort of cue
so I might add a
list and we saw two different types of
URLs if https is in the URL then
basically our URL is already a full
URL full URL
however if it's just the IP stuff then
our full URL would be equal
to and then basically we will want
to append this link to our product
links this is just basically things
we'll search
for and then we'll want to return our
product
links
cool so now let's test out to see if
this works so let's create a main
function how we get product links for a
search term like computers
run
that and we do see we get a bunch of
links cool this looks pretty good so now
if we wanted to create some sort of kind
of like you could either do the a
database use something like mongod DB or
SQL light or you could even save some of
this stuff locally it depends on how
complex you want to get but basically
what we could do is do a loop over get
product links and and uh extract product
info and basically combine the two
things and uh save the
results so what that might look like I'm
going to save this as a Json lines file
so I'll call this output file
equals and then we'll write to our
output file
we can Loop over a search query so how
about links equals product or get
product links
computers how we make this a while
true while true links equals get product
Links Page
number and we can start popping off
links not product
links if not
links how about or if we get you know
once we get past the first 100 Pages
we're probably fine also breaking or
page
number greater than
99 we break out of the loop iterate over
the
links and we will go ahead and product
info equals extract product info on this
link and then if we do get a result or
something like that we might
right to our
file and we should also add a new line
to this because this is a Json lines
file so basically each dictionary will
be its own line and it's probably good
practice for us to surround this in a
tri accept
then we'll want to increase the page
number by one and we
might show that we're going to a next
page cool this is a basic way but this
should scrape all of our computer
information I believe and we'll see if
this
works there we go oops messed up the
syntax there
and while this runs we can kind of check
to see if it's working by looking at the
file and see if lines of Json are being
added and we do see items being
added again all of the code is linked in
the description and I'll kind of break
it down by where we're at in the
video so that finished scraping and if
we look at our product info uh we can
see we have a bunch of product scraped I
think there's a couple ways that I would
improve this though I think one of the
big ones is that this wasn't quite smart
on what products we scraped so if you
look you'll see like some items pop up
all the time like this Acer Chromebook
so there's two different ways you could
kind of solve this problem is you could
check the item ID and only add items to
your kind of cue of links to search if
you hadn't already added it already and
you could do that by the item ID or you
could kind of the simpler solution might
be just look at the link that you're
scraping um here and if you've already
seen that link before don't scrape the
info another thing we might want to do
too is that this ran successfully but we
only had one search term computers what
if you wanted to look up a bunch of
things what would that look like and
would this same system be able to
operate there I'm going to paste in some
code with these changes uh again both
the code you see currently and this new
code all available in the description on
GitHub but we'll go ahead and paste this
in couple changes now some of the
variable names have changed but we have
now multiple search queries so computers
is still there but we have other items
as well that we're going to be looking
at and we're going to use a que to kind
of keep track of what products to look
at as well as we'll keep track of URLs
we've already seen in the scene URLs but
the process is just about the same also
have some print statements to kind of
show what we're doing run a query get
all the links same as before add it to
the product info but now we can just
scrap more info and what does that look
like we can go ahead and run
this and we see all the URLs processing
one issue is that we just overwrote the
original file we made so this is why you
might want to go to like a online mongod
where you're always just adding items to
something instead of using doing the
risky way of writing local files uh
because this video is focused on web
scraping not necessarily how to Output
things I'm going to leave it as is for
now but that's kind of one way you can
improve this project on your own and so
I'll fast forward and let this run and
ultimately so what you'll see is that it
ran a bunch of these products but as we
got through different search queries of
eventually Walmart blocked blocked our
IP address and basically said no more
scraping it kind of saw that what we
were doing because we kept making
requests with the same exact IP address
and it does not like that so what do you
do if you're in this situation where you
need to keep scraping but you're
physically getting blocked by a site
like walmart.com That's not liking what
you're doing this is exactly where
bright
data comes in so if you use the link in
the description you'll get $15 free doar
for bright data but basically our IP got
blocked and you still want to scrape so
this is where some bright data tools can
come in so I already created an account
but if you haven't I recommend you know
starting free trialer setting up with
Google again Link in the description
will give you $15 free dollars so
definitely sign up using that link I'm
going to go to user my user dashboard
and what we'll do to start I'll show
some other stuff but we're going to to
use what's known as a proxy so basically
a proxy Network allows us to send
requests from different spots basically
so if you think of the way we normally
do it we have one single computer which
has a IP address associated with it and
every request has that IP when you use
uh bright data proxy server our request
goes through bright data and then bright
data allows us to make requests as many
different IPS many different locations
and thus makes it much much more
difficult to block the requests we're
making basically we can set our proxy
server up in whatever way so that we
make sure that we get our requests
through so we're going to click on a few
proxy products and we can go ahead and
add a new one I think that I would
recommend probably a good starting point
is Data Center proxies and there's
different ways you can approach this
let's say you needed to use the same IP
address for every one of your requests
when you come back and run this again
maybe you had some sort of white listing
on a server that it's communicating with
and you wanted to make sure it was set
number of ips you could do dedicated you
could also do premium but I think for
most use cases the shared pool of data
center IPS is probably going to be
exactly what you need this basically is
just a massive pool of different IP
addresses and different people at
different times can use in kind of use
from this pool here we see number of ips
so we're not going to play around with
here what we can do is actually go into
Advanced options and I'm going to switch
to pay for usage basically gives us
access to 10,000 plus IPS it really
depends on how much you expect to use
what I'd recommend is you can kind of as
you run your jobs you can kind of see
the costs and decide whether or not
paying per IP or paying per usage makes
more sense I'll give this a name called
like
scraping
proxy so we're going to go ahead and add
this
yes there's some Advanced options here
but most important thing we will want to
do is basically keep track of our host
username and password I'll blur these
out I'll show how we can actually
leverage this information in our
beautiful super requests um we also can
see statistics as we actually start
using our proxy but um we see some
example python code here if we go into
the documentation I believe we can see
some more um python
code I like this a lot this already has
some requests Library stuff I think we
can go ahead basically and
copy this all into our code so I'm going
to paste this
in um our username and password will
have to change what I recommend for
username and password word is you can
create a EnV file in your repo you can
set a I'm going to call this a bright
data
username equals and a bright data
password equals and we'll just do this
for example test and test password and
then basically on our code side what we
can
do okay so in our code um we could just
run this but we can just modify our
existing code to leverage this we need
to fix our username and password so what
we can do is import what's known
asnv and actually what we'll want to do
is from. EnV import load. EnV and if we
run load. n basically this then creates
environment variables for us to use
based on the environment we set here in
ourm file that's within the same folder
as our scraper code also want to import
OS and now basically what we can do is
if I went ahead and set this to os.
Environ BRD username and we set this to
os. Environ BRD password what we'll see
is if I
print username and
print password we'll see those test
variables that we put in I'm going to
temporarily comment out all this bottom
code right run the file test test
password cool so now I'm going to
actually paste in my password in my
username from The Zone we created next
time I run we'll have access to that and
now we see that in our request.get we
can use proxies there's also this cool
thing where we can do this my ip. Json
and make our request there and actually
see where the
um IP is that we're sending our request
from so let's go ahead
and uncomment all of
this again I'm going to delete this
example code real quick and I'll show
how we can incorporate it in okay so and
I think do we need to change the host at
all let's just check nope the host looks
good it's what it has in the docs docs
are also linked in the description but
we can go ahead now and as a little
sample I going to just use this
URL instead of the search
[Music]
URL and I'll do the same thing with the
product
URL and I just want to show what happens
if I do print do responsejson
here so we just temporarily put in this
URL we run this uh and
basically we see always the same IP
address but if we then decided to
insert proxies equal proxies so we set
our
proxies here based on this proxy URL
which contains our our username and
password and the host
info then what we get after saving that
and including the proxies
and both of our requests when we start
printing out
things we see different IP addresses
every time we send so this little URL is
cool for showing where these requests
are coming from we see it's different
countries and everything uh very cool it
proves that our proxies are working by
passing in proxies like this we can go
ahead and keep the URL as we expected it
to be move this print statement okay our
proxies are passed
in going to delete this stuff kind of
clean up the code a little bit but now
we have access to the bright data proxy
which when we got blocked last time now
that we have
um the bright data proxy set that for
all these search queries we can run them
and basically get around the block that
will happen when we use only a single IP
so that's pretty
cool if you haven't if you're running
into any errors with um accessing things
you might have to do a pip three install
of any new library such
ASN or we also included prettyprint here
so make sure to uh pip 3
install these items if you
didn't Now by using Proxes we kind of
open ourselves up to some other new kind
of potential issues that we want to be
aware of one is maybe the proxy is not
available for a second and a request H
you know trips up or maybe the specific
country that we used in our proxy
request um can't access the website
we're trying to scrape so we want to
make sure we can like fail gracefully if
those types of things happen many
different ways to do this but basically
I feel like it comes down to just being
cognizant in like a try accept to handle
failures properly so I'm going
to um add in some additional error
handling and paste in kind of a more um
error proof way to do this but within
the bright data ecosystem I think one
thing that I would recommend is when you
are looking at the proxies and the
different things um kind of in the DAT
like you could add specific geolocation
targeting in either the shared or
dedicated uh and you see like maybe you
only wanted it to be United
States and you know maybe and you can
even add cities that's pretty cool uh
Canada so this would limit where your
IPS are coming from from uh so if you
find yourself getting blocked based on
the location you know look at things
like this with geolocation targeting or
specific cities uh you can go very
sophisticated pretty cool stuff so
that's good to keep in mind all right
but I'm going to go ahead and paste in a
version of this that handles some
failures a little bit more sophisticated
banner and also I'm going to use more
Search terms because one of the perks of
using the proxy networks is we could
just keep scraping things uh quite nice
so basically
just retries things the basically the
difference here with this code is it
will retry um getting product links or
retry extracting product info with a max
number of retries for each URL and if it
fails ever it will sleep a certain
amount of time um that's dependent on
what we defined as a backoff factor and
the attempt number and just basically
let us make sure that if anything kind
of hiccups that we can process it um
another way you might improve this
further is you could run things in
parallel uh it really depends on what's
most important to you whether it's just
getting the info or getting the info
quickly uh there's different ways you
could play around with this and improve
it further but this is a good starting
point what might you might get blocked
in you know a couple thousand requests
Walmart normally you can do tens and
tens of thousands when using a bright
data proxy Network which is super nice
so I think this covers a lot of the kind
of what you'll need to know when it
comes to Advanced scraping techniques
but I think the next logical step to
take your skills even further is uh
being able to actually automate actions
on a page using a library such as
selenium in Python so if you look up
something like
lenium python bright data you you can
find some good information on how to
kind of get started using
selenium and really yeah selenium is
going to be coming when you let's say
page loads but there's this table that
loads a little bit slower and maybe
after like 5 Seconds it loads in and you
need to access the the information in
the page you can use selenium to like
load the page wait 5 seconds and then
access the information that is slow to
load by using things such as implicitly
weight here through selenium and then
additionally one thing that's super
useful within the bright data ecosystem
is this scraping browser so if you look
at documentation scraping browser
scraping browser configuration python
selenium uh you can find some
information on how to use it but uh one
thing that's really nice about the
scraping browser is if let's say you're
using selenium and you run into some uh
captas and stuff that are particularly
hard to get by uh the the scraping
browser can kind of help you
automatically bypass those so you can
really access that tricky to grab data
programmatically I think because this
video is already a good length we're
going to hold off on all of that if you
want to see selenium python bright data
stuff in more depth let me know in the
comments and I definitely will make
another follow-up video happen but I
think this was good launching off point
that builds off the kind of the basics
that we learned in the original tutorial
hopefully you now have a little bit more
Tools in your tool case especially the
bright data proxy stuff that can help
you kind of take your scraping skills to
the next level with that I think we'll
call the video I hope you learned
something I hope you enjoyed this video
if you did means a lot if you throw it a
thumbs up and click the Subscribe button
if you haven't
already um yeah got a bunch of tutorials
on the way thank you to Bright data
again for sponsoring this video link to
get your first $15 free on bright data
down in the description I think that is
it until next time everyone
peace
out one quick question before we go I'm
just super curious how all of you plan
on taking the knowledge from this video
on accessing web data via web scraping
and applying it to your own projects so
we' be super curious to hear what types
of projects you all want to work on with
this knowledge let me know in the
comments it's always fun to read through
what what you all are working on all
right now I'm really out
peace now