Web scrapping introduction
Tags: python, linux, webdev
Published: 2021-05-08 19:36:39

Web scraping is the method of crawling different websites and extracting the required data with spiders. This data is interpreted and stored in a hierarchical format using a data pipeline. Web crawling is now commonly used and has a wide range of applications: This is also applicable in the **advanced Recons** and many more application can be delivered from it.

*Marketing and sales* firms can obtain lead-related information by using site scraping. Web scraping is useful for Real Estate companies to obtain information about new developments, resale homes, and so on. Price comparison websites, such as Trivago, rely heavily on web crawling to obtain product and price details from different e-commerce pages.

Web scraping typically entails spiders retrieving HTML documents from related websites, extracting the required material based on business logic, and storing it in a specific format. This blog serves as a primer for creating extremely scalable scrappers. We will go through the following topics:

### Scraping Techniques:
We'll look at some code snippets that demonstrate simple scraping techniques and frameworks in Python.
Scraping at scale: While scraping a single page is easy, handling the spider code, extracting data, and maintaining a data warehouse are all problems while scraping millions of websites. We'll look at these issues and how to overcome them in order to make scraping easier.

### Scraping Guidelines:
It is considered malicious to scrape data from websites without the owner's consent. Certain rules must be met in order to save our scrappers from being blacklisted. We'll look at some of the better crawling techniques to pursue.
## python libraries for the WebScrapping
**Requests:** Python HTTP Library: To scrape a website or a blog, first retrieve the HTML page's content from an HTTP answer object. Python's requests library is very useful and easy to use. It makes use of urllib internally. I like ‘requests' because it is simple and the code becomes more readable.

**BeautifulSoup:** The next step is to remove the data from the webpage. BeautifulSoup is a robust Python library that assists you in extracting data from web pages. It's simple to use and has a plethora of APIs to assist you in extracting info. We use the requests library to fetch an HTML page, which we then decode using BeautifulSoup. 

**Python library lxml.html:** This is another Python library, similar to BeautifulSoup. Scrapy's internal language is lxml. It includes a list of APIs that can be used to extract data. Why will you do this because Scrapy will extract the data for you? If you want to iterate over the ‘div' tag and perform any procedure on of tag included inside “div,” you can use this library, which will provide you with a list of ‘div' tags. You can now iterate over them with the iter() feature, traversing each child tag inside the parent div tag. In scraping, such traversing operations are difficult. This library's history can be found here.

So now when we want to do web scrapping for the industry level. Let's take a look at the problems and solutions that come with scraping on a wide scale, i.e., scraping 100–200 websites on a daily basis:

## Data Warehousing:

**Large-scale** data mining produces massive amounts of material. A data warehouse must have fault tolerance, scalability, security, and high availability. If the data warehouse is unstable or inaccessible, activities such as data search and filtering would be inefficient. Instead of running your own servers or infrastructure, you can use Amazon Web Services to do this (AWS). RDS (Relational Database Service) can be used for hierarchical databases and DynamoDB for non-relational databases. AWS is in charge of data backup. It immediately creates a backup of the servers. It also provides database error logs. This blog discusses how to set up cloud computing for scraping.

**change in the Process and the data that is being saved online.**

Scraping is largely reliant on the user interface and its structure, specifically CSS and Xpath. Now, if the target website changes, our scraper can crash or return random data that we don't like. This is a typical case, which is why maintaining scrapers is more complex than composing them. To manage this case, we should create test cases for the extraction logic and run them on a regular basis, either manually or via CI software like Jenkins, to see how the goal website has modified.

Robots and the Captcha which is not allowing the parsers to get in.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lu8gjgp9gfcr3ipxdzbw.PNG)

Web scraping is popular these days, and any website host will like to save their data from being scraped. Anti-scraping technology will aid them in this endeavor. For example, if you visit a specific website from the same IP address on a regular basis, the target website will block your IP address. Using a captcha on a website will also support. There are ways to get around these anti-scraping measures. Or example, we may use proxy servers to conceal our true IP address. There are some proxy services that rotate the IP address before each request. It is also simple to add support for proxy servers to the code, and the Scrapy module in Python does so.

JIT Compiled languages make it more tough to get the parsers as the lava script is very different from HTML.

Data extraction is difficult on websites that rely heavily on JavaScript and Ajax to render complex content. Scrapy and similar frameworks/libraries can no longer run or remove something from the HTML code. Since Ajax calls and JavaScript are executed at runtime, it cannot scrape them. This can be addressed by rendering the web page in a headless browser, such as Headless Chrome.

Some websites use honeypot traps on their webpages to track web crawlers. They are difficult to spot since the majority of the ties are merged with the background color or have the show property of CSS set to zero. This technique is rarely used because it necessitates significant coding activities on both the server and crawler sides.


AI and ML applications are currently in high demand, and these projects require vast amounts of data. Data integrity is also critical since a single flaw in AI/ML algorithms may cause serious problems. Thus, when scraping, it is important not only to scrape the data but also to check its integrity. Since doing this in real-time is not always feasible, I would rather write test cases for the extraction log. So, I'd rather write test cases for the extraction logic to ensure that whatever your spiders are collecting is right and that they're not scraping wrong data.

Python multithreading scraping packages such as Frontera and Scrapy Redis are available. Frontera only allows you to submit one request per domain at a time, but it can reach several domains at the same time, making it ideal for concurrent scraping. Scrapy Redis allows you to submit multiple requests to a single domain. The best mix of these will result in a very strong web spider capable of dealing with both the bulk and variety of large websites.

This one is self-evident. The longer it takes to scrape a page, the bigger it is and the more data it holds. This is good if the reason for searching the web isn't time-sensitive, but this isn't always the case. Stock values do not remain constant over time. Time-sensitive data includes sales listings, currency exchange rates, media patterns, and stock values, to name a few examples. So, what do you do in this situation? One answer may be to properly plan the spiders. If you're using a Scrapy-like system, make sure to use proper Link Extractor rules so that the spider doesn't waste time scratching unrelated URLs.

**Conclusion:** We've covered the fundamentals of scraping, structures, crawling techniques, and best scraping methods. Finally, when scratching, adhere to the laws of the goal URLs. Don't force them to obstruct your spider. It is impossible to keep details and spiders up to date on a large scale. To conveniently scale the site scraping backend, use Docker/ Kubernetes and public cloud services such as AWS.
Often follow the guidelines of the pages you want to crawl. Often use APIs first if they are usable.

### Scrapping Best tricks and Tips to get the work moving:
* **Never parse a server very frequently**: As it will make a track of your id and you also may get scrutinized for doing so.
* **Use agent rotation and spoofing**: Each request includes a User-Agent string in the header. This string identifies the browser you're using, as well as its version and platform. If we use the same User-Agent with any submission, the goal website can easily determine that the request is coming from a crawler. Thus, you can be safe and away from legal liabilities.
* **Don't parse with the same approach every time**: try changing tools or maybe try changing the framework and also if possible, use as many proxies as you can.
* **Use the scrapped data responsibly** : if possible, scrape the content with permission or else don't even try doing it and be absolutely professional and clear with the way that you will be using the scrapped data.

I will write some code and will be doing some demo videos here thus bookmark this article you will find some new edits for the future.

Thank you.