Web crawler

See WebCrawler for the specific search engine of that name.

---

A web crawler (also known as a web spider or ant) is a program which browses the World Wide Web in a methodical, automated manner. Web crawlers are mainly used to create a copy of all the visited pages for later processing by a search engine, that will index the downloaded pages to provide fast searches.

A web crawler is one type of bot, or software agent. In general, it starts with a list of URLs to visit. As it visits these URLs, it identifies all the hyperlinks in the page and adds them to the list of URLs to visit, recursively browsing the Web according to a set of policies.

Contents

1 Crawling policies 1.1 Selection policy 1.2 Re-visit policy 1.3 Politeness policy 1.4 Parallelization policy 2 Web crawler architectures 2.1 Examples of Web crawlers 3 References 4 External links

Crawling policies

There are two important characteristics of the Web that generate a scenario in which Web crawling is very difficult: its large volume and its rate of change, as there is a huge amount of pages being added, changed and removed every day. Also, network speed has improved less than current processing speeds and storage capacities.

The large volume implies that the crawler can only download a fraction of the Web pages within a given time, so it needs to prioritize its downloads. The high rate of change implies that by the time the crawler is downloading the last pages from a site, it is very likely that new pages have been added to the site, or that pages have already been updated or even deleted.

As Edwards et al. note, "Given that the bandwidth for conducting crawls is neither infinite nor free it is becoming essential to crawl the Web in a not only scalable, but efficient way if some reasonable measure of quality or freshness is to be maintained." (Edwards et al., 2001). A crawler must carefully choose at each step which pages to visit next.

The behavior of a Web crawler is the outcome of a combination of policies:

• A selection policy that states which pages to download.
• A re-visit policy that states when to check for changes to the pages.
• A politeness policy that states how to avoid overloading Web sites.
• A parallelization policy that states how to coordinate distributed Web crawlers.

Selection policy

Given the current size of the Web, even large search engines cover only a portion of the publicly available content; a study by Lawrence and Giles (Lawrence and Giles, 2000) showed that no search engine indexes more than 16% of the Web. As a crawler always downloads just a fraction of the Web pages, it is highly desirable that the downloaded fraction contains the most relevant pages, and not just a random sample of the Web.

This requires a metric of importance for prioritizing Web pages. The importance of a page is a function of its intrinsic quality, its popularity in terms of links or visits, and even of its URL (the latter is the case of vertical search engines restricted to a single top-level domain, or search engines restricted to a fixed Website). Designing a good selection policy has an added difficulty: it must work with partial information, as the complete set of Web pages is not known during crawling.

Cho et al. (Cho et al., 1998) made the first study on policies for crawling scheduling. Their data set was a 180,000-pages crawl from the stanford.edu domain, in which a crawling simulation was done with different strategies. The ordering metrics tested were breadth-first, backlink-count and partial Pagerank calculations. One of the conclusions was that if the crawler wants to download pages with high Pagerank early during the crawling process, then the partial Pagerank strategy is the better, followed by breadth-first and backlink-count. However, these results are for just a single domain.

Najork and Wiener (Najork and Wiener, 2001) performed an actual crawl on 328 million pages, using breadth-first ordering. They found that a breadth-first crawl captures pages with high Pagerank early in the crawl (but they did not compare this strategy against other strategies). The explanation given by the authors for this result is that "the most important pages have many links to them from numerous hosts, and those links will be found early, regardless of on which host or page the crawl originates".

Abiteboul (Abitebout et al., 2003) designed a crawling strategy based on an algorithm called OPIC (On-line Page Importance Computation). In OPIC, each page is given an initial sum of "cash" which is distributed equally among the pages it points to. It is similar to a Pagerank computation, but it is faster and is only done in one step. An OPIC-driven crawler downloads first the pages in the crawling frontier with higher amounts of "cash". Experiments were carried in a 100,000-pages synthetic graph with a power-law distribution of in-links. However, there was no comparison with other strategies nor experiments in the real Web.

Boldi et al. (Boldi et al., 2004) used simulation on subsets of the Web of 40 million pages from the .it domain and 100 million pages from the WebBase crawl, testing breadth-first against random ordering and an omniscient strategy. The winning strategy was breadth-first, although a random ordering also performed surprisingly well. One problem is that the WebBase crawl is biased to the crawler used to gather the data. They also showed how bad Pagerank calculations carried on partial subgraphs of the Web, obtained during crawling, can approximate the actual Pagerank.

Baeza-Yates et al. (Baeza-Yates et al., 2005) used simulation on two subsets of the Web of 3 million pages from the .gr and .cl domain, testing several crawling strategies. They showed that both the OPIC strategy and an strategy that uses the length of the per-site queues are both better than breadth-first crawling, and that it is also very effective to use a previous crawl, when it is available, to guide the current one.

Focused crawling: The importance of a page for a crawler can also be expressed as a function of the similarity of a page to a given query. This is called "focused crawling" and was introduced by Chakrabarti et al. (Chakrabarti et al., 1999).

The main problem in focused crawling is that in the context of a Web crawler, we would like to be able to predict the similarity of the text of a given page to the query before actually downloading the page. A possible predictor is the anchor text of links; this was the approach taken by Pinkerton (Pinkerton, 1994) in a crawler developed in the early days of the Web. Diligenti et al. (Diligenti et al., 2000) propose to use the complete content of the pages already visited to infer the similarity between the driving query and the pages that have not been visited yet. The performance of a focused crawling depends mostly on the richness of links in the specific topic being searched, and a focused crawling usually relies on a general Web search engine for providing starting points.

A related problem for selecting pages is that nowadays, most pages on the Web are generated submitting queries to databases, and those pages cannot be ignored. See deep web.

Re-visit policy

The Web has a very dynamic nature, and crawling a fraction of the Web can take a long time, usually measured in weeks or months. By the time a Web crawler has finished its crawl, many events could have happened. These events can include creations, updates and deletions.

From the search engine's point of view, there is a cost associated with not detecting an event, and thus having an outdated copy of a resource. The most used cost functions, introduced in (Cho and Garcia-Molina, 2000), are freshness and age.

Freshness: This is a binary measure that indicates whether the local copy is accurate or not. The freshness of a page p in the repository at time t is defined as:

<math> F_p(t) = \begin{cases} 1 & {\rm if}~p~{\rm~is~equal~to~the~local~copy~at~time}~t\\ 0 & {\rm otherwise} \end{cases} <math>

Age This is a measure that indicates how outdated the local copy is. The age of a page p in the repository, at time t is defined as:

<math> A_p(t) = \begin{cases} 0 & {\rm if}~p~{\rm~is~not~modified~at~time}~t\\ t - {\rm modification~time~of}~p & {\rm otherwise} \end{cases} <math>

Coffman et al. (Edward G. Coffman, 1998) worked with a definition of the objective of a Web crawler that is equivalent to freshness, but use a different wording: they propose that a crawler must minimize the fraction of time pages remain outdated. They also noted that the problem of Web crawling can be modeled as a multiple-queue, single-server polling system, on which the Web crawler is the server and the Web sites are the queues. Page modifications are the arrival of the customers, and switch-over times are the interval between page accesses to a single Web site. Under this model, mean waiting time for a customer in the polling system is equivalent to the average age for the Web crawler.

The objective of the crawler is to keep the average freshness of pages in its collection as high as possible, or to keep the average age of pages as low as possible. These objectives are not equivalent: in the first case, the crawler is just concerned with how many pages are out-dated, while in the second case, the crawler is concerned with how old the local copies of pages are.

Two simple re-visiting policies were studied by Cho and Garcia-Molina (Cho and Garcia-Molina, 2003):

Uniform policy: This involves re-visiting all pages in the collection with the same frequency, regardless of their rates of change.

Proportional policy: This involves re-visiting more often the pages that change more frequently. The visiting frequency is directly proportional to the (estimated) change frequency.

(In both cases, the repeated crawling order of pages can be done either at random or with a fixed order.)

Cho and Garcia-Molina proved the surprising result that, in terms of average freshness, the uniform policy outperforms the proportional policy in both a simulated Web and a real Web crawl. The explanation for this result comes from the fact that, when a page changes too often, the crawler will waste time by trying to re-crawl it too fast and still will not be able to keep its copy of the page fresh.

To improve freshness, we should penalize the elements that change too often (Cho and Garcia-Molina, 2003a). The optimal re-visiting policy is neither the uniform policy nor the proportional policy. The optimal method for keeping average freshness high includes ignoring the pages that change too often, and the optimal for keeping average age low is to use access frequencies that monotonically (and sub-linearly) increase with the rate of change of each page. In both cases, the optimal is closer to the uniform policy than to the proportional policy: as Coffman et al. (Edward G. Coffman, 1998) note, "in order to minimize the expected obsolescence time, the accesses to any particular page should be kept as evenly spaced as possible". Explicit formulas for the re-visit policy are not attainable in general, but they are obtained numerically, as they depend on the distribution of page changes. Note that the re-visiting policies considered here regard all pages as homogeneous in terms of quality ("all pages on the Web are worth the same"), something that is not a realistic scenario, so further information about the Web page quality should be included to achieve a better crawling policy.

Politeness policy

As noted by Koster (Koster, 1995), the use of Web robots is useful for a number of tasks, but comes with a price for the general community. The costs of using Web robots include:

• Network resources, as robots require considerable bandwidth, and operate with a high degree of parallelism during a long period of time.
• Server overload, especially if the frequency of accesses to a given server is too high.
• Poorly written robots, which can crash servers or routers, or which download pages they cannot handle.
• Personal robots that, if deployed by too many users, can disrupt networks and Web servers.

A partial solution to these problems is the robots exclusion protocol, also known as the robots.txt protocol (Koster, 1996) that is a standard for administrators to indicate which parts of their Web servers should not be accessed by robots. This standard does not include a suggestion for the interval of visits to the same server, even though this interval is the most effective way of avoiding server overload.

The first proposal for the interval between connections was given in (Koster, 1993) and was 60 seconds. However, if we download pages at this rate from a Web site with more than 100,000 pages over a perfect connection with zero latency and infinite bandwidth, it would take more than 2 months to download only that entire Web site; also, we would be using a fraction of the resources from that Web server permanently. This does not seems acceptable.

Cho (Cho and Garcia-Molina, 2003) uses 10 seconds as an interval for accesses, and the WIRE crawler (Baeza-Yates and Castillo, 2002) uses 15 seconds as the default. The MercatorWeb crawler (Heydon and Najork, 1999) follows an adaptive politeness policy: if it took t seconds to download a document from a given server, the crawler waits for 10*t seconds before downloading the next page. Dill et al. (Dill et al., 2002) use 1 second.

Anecdotal evidence from access logs shows that access intervals from known crawlers vary between 20 seconds and 3-4 minutes. It is worth noticing that even when being very polite, and taking all the safeguards to avoid overloading Web servers, some complaints from Web server administrators are received. Brin and Page note that: "... running a crawler which connects to more than half a million servers (...) generates a fair amount of email and phone calls. Because of the vast number of people coming on line, there are always those who do not know what a crawler is, because this is the first one they have seen." (Brin and Page, 1998).

Parallelization policy

A parallel crawler is a crawler that runs multiple process in parallel. The goal is to maximize the download rate while minimizing the overhead from parallelization and to avoid repeated downloads of the same page. To avoid downloading the same page more than once, the crawling system requires a policy for assigning the new URLs discovered during the crawling process, as the same URL can be found by two different crawling processes. Cho and Garcia-Molina (Cho and Garcia-Molina, 2002) studied two types of policy:

Dynamic assignment: With this type of policy, a central server assigns new URLs to different crawlers dynamically. This allows the central server to, for instance, dynamically balance the load of each crawler.

With dynamic assignment, typically the systems can also add or remove downloader processes. The central server may become the bottleneck, so most of the workload must be transferred to the distributed crawling processes for large crawls.

There are two configurations of crawling architectures with dynamic assignment that have been described by Shkapenyuk and Suel (Shkapenyuk and Suel, 2002):

• A small crawler configuration, in which there is a central DNS resolver and central queues per Web site, and distributed downloaders.
• A large crawler configuration, in which the DNS resolver and the queues are also distributed.

Static assignment: With this type of policy, there is a fixed rule stated from the beginning of the crawl that defines how to assign new URLs to the crawlers.

For static assignment, a hashing function can be used to transform URLs (or, even better, complete Web site names) into a number that corresponds to the index of the corresponding crawling process. As there are external links that will go from a Web site assigned to one crawling process to a Web site assigned to a different crawling process, some exchange of URLs must occur.

To reduce the overhead due to the exchange of URLs between crawling processes, the exchange should be done in batch, several URLs at a time, and the most cited URLs in the collection should be known by all crawling processes before the crawl (e.g.: using data from a previous crawl) (Cho and Garcia-Molina, 2002).

An effective assignment function must have three main properties: each crawling process should get approximately the same number of hosts (balancing property), if the number of crawling processes grows, the number of hosts assigned to each process must shrink (contra-variance property), and the assignment must be able to add and remove crawling processes dynamically. Boldi et al. (Boldi et al., 2004) propose to use consistent hashing, which replicates the buckets, so adding or removing a bucket does not requires re-hashing of the whole table to achieve all of the desired properties.

Web crawler architectures

A crawler must have a good crawling strategy, as noted in the previous sections, but it also needs a highly optimized architecture. Shkapenyuk and Suel (Shkapenyuk and Suel, 2002) noted that: "While it is fairly easy to build a slow crawler that downloads a few pages per second for a short period of time, building a high-performance system that can download hundreds of millions of pages over several weeks presents a number of challenges in system design, I/O and network efficiency, and robustness and manageability."

Web crawlers are a central part of search engines, and details on their algorithms and architecture are kept as business secrets. When crawler designs are published, there is often an important lack of detail that prevents other from reproducing the work. There are also emerging concerns about "search engine spamming", which prevent major search engines from publishing their ranking algorithms.

Examples of Web crawlers

The following is a list of published crawler architectures for general-purpose crawlers (excluding focused Web crawlers), with a brief description that includes the names given to the different components and outstanding features:

RBSE (Eichmann, 1994) was the first published Web crawler. It was based on two programs: the first program, "spider" maintains a queue in a relational database, and the second program "mite", is a modified www ASCII browser that downloads the pages from the Web.

WebCrawler (Pinkerton, 1994) was used to build the first publicly-available full-text index of a sub-set of theWeb. It was based on lib-WWW to download pages, and another program to parse and order URLs for breadth-first exploration of the Web graph. It also included a real-time crawler that followed links based on the similarity of the anchor text with the provided query.

World Wide Web Worm (McBryan, 1994) was a crawler used to build a simple index of document titles and URLs. The index could be searched by using the grep UNIX command.

Internet Archive Crawler (Burner, 1997) is a crawler designed with the purpose of archiving periodic snapshots of a large portion of the Web. It uses several process in a distributed fashion, and a fixed number of Web sites are assigned to each process. The inter-process exchange of URLs is carried in batch with a long time interval between exchanges, as this is a costly process. The Internet Archive Crawler also has to deal with the problem of changing DNS records, so it keeps an historical archive of the hostname to IP mappings.

WebSPHINX (http://www.cs.cmu.edu/~rcm/websphinx/) (Miller and Bharat, 1998) is composed of a Java class library that implements multi-threaded Web page retrieval and HTML parsing, and a graphical user interface to set the starting URLs, to extract the downloaded data and to implement a basic text-based search engine.

Google Crawler (Brin and Page, 1998) is described in some detail, but the reference is only about an early version of its architecture, which was based in C++ and Python. The crawler was integrated with the indexing process, because text parsing was done for full-text indexing and also for URL extraction. There is an URL server that sends lists of URLs to be fetched by several crawling processes. During parsing, the URLs found were passed to a URL server that checked if the URL have been previously seen. If not, the URL was added to the queue of the URL server.

CobWeb (da Silva et al., 1999) uses a central "scheduler" and a series of distributed "collectors". The collectors parse the downloaded Web pages and send the discovered URLs to the scheduler, which in turns assign them to the collectors. The scheduler enforces a breadth-first search order with a politeness policy to avoid overloading Web servers. The crawler is written in Perl.

Mercator (Heydon and Najork, 1999) is a modular Web crawler written in Java. Its modularity arises from the usage of interchangeable "protocol modules" and "processing modules". Protocols modules are related to how to acquire the Web pages (e.g.: by HTTP), and processing modules are related to how to process Web pages. The standard processing module just parses the pages and extract new URLs, but other processing modules can be used to index the text of the pages, or to gather statistics from the Web.

WebFountain (Edwards et al., 2001) is a distributed, modular crawler similar to Mercator but written in C++. It features a "controller" machine that coordinates a series of "ant" machines. After repeatedly downloading pages, a change rate is inferred for each page and a non-linear programming method must be used to solve the equation system for maximizing freshness. The authors recommend to use this crawling order in the early stages of the crawl, and then switch to a uniform crawling order, in which all pages being visited with the same frequency.

PolyBot [Shkapenyuk and Suel, 2002] is a distributed crawler written in C++ and Python, which is composed of a "crawl manager", one or more "downloaders" and one or more "DNS resolvers". Collected URLs are added to a queue on disk, and processed later to search for seen URLs in batch mode. The politeness policy considers both third and second level domains (e.g.: www.example.com and www2.example.com are third level domains) because third level domains are usually hosted by the same Web server.

WebRACE (Zeinalipour-Yazti and Dikaiakos, 2002) is a crawling and caching module implemented in Java, and used as a part of a more generic system called eRACE. The system receives requests from users for downloading Web pages, so the crawler acts in part as a smart proxy server. The system also handles requests for "subscriptions" to Web pages that must be monitored: when the pages change, they must be downloaded by the crawler and the subscriber must be notified. The most outstanding feature of WebRACE is that, while most crawlers start with a set of "seed" URLs, WebRACE is continuously receiving new starting URLs to crawl from.

Ubicrawler (http://ubi.imc.pi.cnr.it/projects/ubicrawler/) (Boldi et al., 2004) is a distributed crawler written in Java, and it has no central process. It is composed of a number of identical "agents"; and the assignment function is calculated using consistent hashing of the host names. There is zero overlap, meaning that no page is crawled twice, unless a crawling agent crashes (then, another agent must re-crawl the pages from the failing agent). The crawler is designed to achieve high scalability and to be tolerant to failures.

FAST Crawler (Risvik and Michelsen, 2002) is the crawler used by the FAST search engine, and a general description of its architecture is available. It is a distributed architecture in which each machine holds a "document scheduler" that maintains a queue of documents to be downloaded by a "document processor" that stores them in a local storage subsystem. Each crawler communicates with the other crawlers via a "distributor" module that exchanges hyperlink information.

WIRE (http://www.cwr.cl/projects/WIRE) (Baeza-Yates and Castillo, 2002) is a Web crawler written in C++, including several policies for scheduling the page downloads and a module for generating reports and statistics on the downloaded pages so it has been used for Web characterization.

In addition to the specific crawler architectures listed above, there are general crawler architectures published by Cho (Cho and Garcia-Molina, 2002) and Chakrabarti (Chakrabarti, 2003). Also, a few Web crawlers have been released under the GNU public license: Larbin (http://larbin.sourceforge.net/index-eng.html) , WebBase (http://www-diglib.stanford.edu/~testbed/doc2/WebBase/), a free version of WebSPHINX (http://www.cs.cmu.edu/~rcm/websphinx/), GRUB (http://www.grub.org/) and HTDig (http://www.htdig.org/).

References

See also: Google, PageRank, Data mining

• Serge Abiteboul, Mihai Preda, and Gregory Cobena. Adaptive on-line page importance computation. (http://www-db.deis.unibo.it/courses/SI-LS/papers4pres/APC03.pdf) In Proceedings of the twelfth international conference on World Wide Web, pages 280-290, Budapest, Hungary, 2003. ACM Press.
• Baeza-Yates, R. and Castillo, C. (2002). Balancing volume, quality and freshness in web crawling (http://www.dcc.uchile.cl/~ccastill/papers/baeza02balancing.pdf). In Soft Computing Systems - Design, Management and Applications, pages 565-572, Santiago, Chile. IOS Press Amsterdam.
• Baeza-Yates, R., Castillo, C., Marin, M. and Rodriguez, A. (2005). Crawling a Country: Better Strategies than Breadth-First for Web Page Ordering (http://www.dcc.uchile.cl/%7Eccastill/papers/baeza05_crawling_country_better_breadth_first_web_page_ordering.pdf). In Proceedings of the Industrial and Practical Experience track of the 14th conference on World Wide Web, pages 864-872, Chiba, Japan. ACM Press.
• Boldi, P., Codenotti, B., Santini, M., and Vigna, S. (2004a). UbiCrawler: a scalable fully distributed Web crawler (http://vigna.dsi.unimi.it/ftp/papers/UbiCrawler.pdf). Software, Practice and Experience, 34(8):711-726.
• Boldi, P., Santini, M., and Vigna, S. (2004b). Do your worst to make the best: Paradoxical effects in pagerank incremental computations (http://vigna.dsi.unimi.it/ftp/papers/ParadoxicalPageRank.pdf). In Proceedings of the third Workshop on Web Graphs (WAW), volume 3243 of Lecture Notes in Computer Science, pages 168-180, Rome, Italy. Springer.
• Brin, S. and Page, L. (1998). The anatomy of a large-scale hypertextual Web search engine (http://www-db.stanford.edu/~backrub/google.html). Computer Networks and ISDN Systems, 30(1-7):107-117.
• Burner, M. (1997). Crawling towards eternity - building an archive of the World Wide Web (http://www.webtechniques.com/archives/1997/05/burner/). Web Techniques, 2(5).
• Chakrabarti, S. (2003). Mining the Web. Morgan Kaufmann Publishers.
• Chakrabarti, S., van den Berg, M., and Dom, B. (1999). Focused crawling: a new approach to topic-specific web resource discovery (http://www.fxpal.com/people/vdberg/pubs/www8/www1999f.pdf). Computer Networks, 31(11-16):1623-1640.
• Junghoo Cho, Hector Garcia-Molina, and Lawrence Page. Efficient crawling through URL ordering (http://www.csd.uch.gr/~hy558/papers/cho-order.pdf). In Proceedings of the seventh conference on World Wide Web, Brisbane, Australia, April 1998.
• Cho, J. and Garcia-Molina, H. (2000). Synchronizing a database to improve freshness (http://www.cs.brown.edu/courses/cs227/2002/cache/Cho.pdf). In Proceedings of ACM International Conference on Management of Data (SIGMOD), pages 117-128, Dallas, Texas, USA.
• Cho, J. and Garcia-Molina, H. (2002). Parallel crawlers (http://rose.cs.ucla.edu/~cho/papers/cho-parallel.pdf). In Proceedings of the eleventh international conference on World Wide Web, pages 124-135, Honolulu, Hawaii, USA. ACM Press.
• Cho, J. and Garcia-Molina, H. (2003). Effective page refresh policies for web crawlers (http://rose.cs.ucla.edu/~cho/papers/cho-tods03.pdf). ACM Transactions on Database Systems, 28(4).
• Cho, J. and Garcia-Molina, H. (2003). Estimating frequency of change (http://rose.cs.ucla.edu/~cho/papers/cho-freq.pdf). ACM Transactions on Internet Technology, 3(3).
• Diligenti, M., Coetzee, F., Lawrence, S., Giles, C. L., and Gori, M. (2000). Focused crawling using context graphs (http://nautilus.dii.unisi.it/pubblicazioni/files/conference/2000-Diligenti-VLDB.pdf). In Proceedings of 26th International Conference on Very Large Databases (VLDB), pages 527-534, Cairo, Egypt.
• Dill, S., Kumar, R., Mccurley, K. S., Rajagopalan, S., Sivakumar, D., and Tomkins, A. (2002). Self-similarity in the web (http://alme1.almaden.ibm.com/cs/people/mccurley/pdfs/fractal.pdf). ACM Trans. Inter. Tech., 2(3):205-223.
• Eichmann, D. (1994). The RBSE spider: balancing effective search against Web load (http://mingo.info-science.uiowa.edu/eichmann/www94/Spider.ps). In Proceedings of the First World Wide Web Conference, Geneva, Switzerland.
• Edward G. Coffman, Z. Liu, R. W. (1998). Optimal robot scheduling for Web search engines. Journal of Scheduling, 1(1):15-29.
• Jenny Edwards, Kevin S. McCurley, and John A. Tomlin. An adaptive model for optimizing performance of an incremental web crawler (http://www.almaden.ibm.com/webfountain/resources/AdaptiveModelforCrawling.pdf). In Proceedings of the Tenth Conference on World Wide Web, pages 106–113, Hong Kong, May 2001. Elsevier Science.
• Heydon, A. and Najork, M. (1999). Mercator: A scalable, extensible Web crawler (http://www.cindoc.csic.es/cybermetrics/pdf/68.pdf). World Wide Web Conference, 2(4):219-229.
• Koster, M. (1993). Guidelines for robots writers (http://www.robotstxt.org/wc/guidelines.html).
• Koster, M. (1995). Robots in the web: threat or treat ? ConneXions, 9(4).
• Koster, M. (1996). A standard for robot exclusion (http://www.robotstxt.org/wc/exclusion.html).
• Steve Lawrence and C. Lee Giles. Accessibility of information on the web (http://www.nature.com/doifinder/10.1038/21987). Intelligence,11(1):32–39, 2000.
• McBryan, O. A. (1994). GENVL and WWWW: Tools for taming the web. In Proceedings of the First World Wide Web Conference, Geneva, Switzerland.
• Miller, R. and Bharat, K. (1998). Sphinx: A framework for creating personal, site-specific web crawlers (http://www-2.cs.cmu.edu/~rcm/papers/www7/www7.html). In Proceedings of the seventh conference on World Wide Web, Brisbane, Australia. Elsevier Science.
• Marc Najork and Janet L. Wiener. Breadth-first crawling yields high-quality pages (http://xobjects.seu.edu.cn/xobjects/www10/papers/pdf/p208.pdf). In Proceedings of the Tenth Conference on World Wide Web, pages 114–118, Hong Kong, May 2001. Elsevier Science.
• Pinkerton, B. (1994). Finding what people want: Experiences with the WebCrawler (http://archive.ncsa.uiuc.edu/SDG/IT94/Proceedings/Searching/pinkerton/WebCrawler.html). In Proceedings of the First World Wide Web Conference, Geneva, Switzerland.
• Shkapenyuk, V. and Suel, T. (2002). Design and implementation of a high performance distributed web crawler (http://cis.poly.edu/tr/tr-cis-2001-03.pdf). In Proceedings of the 18th International Conference on Data Engineering (ICDE), pages 357-368, San Jose, California. IEEE CS Press.
• da Silva, A. S., Veloso, E. A., Golgher, P. B., Ribeiro-Neto, B. A., Laender, A. H. F., and Ziviani, N. (1999). Cobweb - a crawler for the Brazilian web (http://www.dcc.fua.br/~alti/pubs/spire99_cow.ps.gz). In Proceedings of String Processing and Information Retrieval (SPIRE), pages 184-191, Cancun, Mexico. IEEE CS Press.
• Zeinalipour-Yazti, D. and Dikaiakos, M. D. (2002). Design and implementation of a distributed crawler and filtering processor (http://www.cs.ucr.edu/~csyiazti/downloads/papers/ngits02/ngits02.pdf). In Proceedings of the Fifth Next Generation nformation Technologies and Systems (NGITS), volume 2382 of Lecture Notes in Computer Science, pages 58-74, Caesarea, Israel. Springer.

External links

• InternetAdSales.com: Robots, Spiders, Crawlers and HTTP_User_Agents (http://www.internetadsales.com/modules/wfsection/index.php?category=23) - Comprehensive listing of common web crawlersde:Webcrawler

fr:Robot d'indexation it:Web crawler nl:Spider ja:クローラ ru:Поисковый робот