Crawlee—A web scraping and browser automation library for Node.js to build reliable crawlers. In JavaScript and TypeScript. Extract data for AI, LLMs, RAG, or GPTs. Download HTML, PDF, JPG, PNG, and other files from websites. Works with Puppeteer, Playwright, Cheerio, JSDOM, and raw HTTP. Both headful and headless mode. With proxy rotation.
TypeScript apifyautomationcrawlercrawlingheadlessheadless-chromejavascriptnodejsnpmplaywrightpuppeteerscraperscrapingtypescriptweb-crawlerweb-crawlingweb-scraping
chore: build docs
Ondra Urbane9c27a92f65c
diff --git a/website/i18n/en.json b/website/i18n/en.jsonindex 13c9859ef..92f5c872a 100644--- a/website/i18n/en.json+++ b/website/i18n/en.json@@ -1078,6 +1078,18 @@},"version-1.1.2/typedefs/version-1.1.2-puppeteer-crawler-options": {"title": "PuppeteerCrawlerOptions"+ },+ "version-1.2.0/api/version-1.2.0-utils": {+ "title": "utils"+ },+ "version-1.2.0/examples/version-1.2.0-use-stealth-mode": {+ "title": "Use stealth mode"+ },+ "version-1.2.0/guides/version-1.2.0-docker-images": {+ "title": "Running in Docker"+ },+ "version-1.2.0/typedefs/version-1.2.0-request-as-browser-options": {+ "title": "RequestAsBrowserOptions"}},"links": {diff --git a/website/versioned_docs/version-1.2.0/api/utils.md b/website/versioned_docs/version-1.2.0/api/utils.mdnew file mode 100644index 000000000..dc11da399--- /dev/null+++ b/website/versioned_docs/version-1.2.0/api/utils.md@@ -0,0 +1,281 @@+---+id: version-1.2.0-utils+title: utils+original_id: utils+---++<a name="utils"></a>++A namespace that contains various utilities.++**Example usage:**++```javascript+const Apify = require('apify');++...++// Sleep 1.5 seconds+await Apify.utils.sleep(1500);+```++---++<a name="url_no_commas_regex"></a>++## `utils.URL_NO_COMMAS_REGEX`++Default regular expression to match URLs in a string that may be plain text, JSON, CSV or other. It supports common URL characters and does not+support URLs containing commas or spaces. The URLs also may contain Unicode letters (not symbols).++---++<a name="url_with_commas_regex"></a>++## `utils.URL_WITH_COMMAS_REGEX`++Regular expression that, in addition to the default regular expression `URL_NO_COMMAS_REGEX`, supports matching commas in URL path and query. Note,+however, that this may prevent parsing URLs from comma delimited lists, or the URLs may become malformed.++---++<a name="enqueuelinks"></a>++## `utils.enqueueLinks(options)`++The function finds elements matching a specific CSS selector (HTML anchor (`<a>`) by default) either in a Puppeteer page, or in a Cheerio object+(parsed HTML), and enqueues the URLs in their `href` attributes to the provided [`RequestQueue`](../api/request-queue). If you're looking to find URLs+in JavaScript heavy pages where links are not available in `href` elements, but rather navigations are triggered in click handlers see+[`puppeteer.enqueueLinksByClickingElements()`](../api/puppeteer#enqueuelinksbyclickingelements).++Optionally, the function allows you to filter the target links' URLs using an array of [`PseudoUrl`](../api/pseudo-url) objects and override settings+of the enqueued [`Request`](../api/request) objects.++**Example usage**++```javascript+await Apify.utils.enqueueLinks({+ page,+ requestQueue,+ selector: 'a.product-detail',+ pseudoUrls: ['https://www.example.com/handbags/[.*]', 'https://www.example.com/purses/[.*]'],+});+```++**Parameters**:++- **`options`**: `object` - All `enqueueLinks()` parameters are passed via an options object with the following keys:++ - **`[page]`**: `PuppeteerPage` | `PlaywrightPage` - Puppeteer [`Page`](https://pptr.dev/#?product=Puppeteer&show=api-class-page) object. Either+ `page` or `$` option must be provided.+ - **`[limit]`**: `Number` - Limit the count of actually enqueued URLs to this number. Useful for testing across the entire crawling scope.+ - **`[$]`**: `cheerio.Root` | `cheerio.Selector` - [`Cheerio`](https://github.com/cheeriojs/cheerio) function with loaded HTML. Either `page` or+ `$` option must be provided.+ - **`requestQueue`**: [`RequestQueue`](../api/request-queue) - A request queue to which the URLs will be enqueued.+ - **`[selector]`**: `string` <code> = "'a'"</code> - A CSS selector matching links to be enqueued.+ - **`[baseUrl]`**: `string` - A base URL that will be used to resolve relative URLs when using Cheerio. Ignored when using Puppeteer, since the+ relative URL resolution is done inside the browser automatically.+ - **`[pseudoUrls]`**: `Array<Object<string, *>>` | `Array.<string>` - An array of [`PseudoUrl`](../api/pseudo-url)s matching the URLs to+ be enqueued, or an array of strings or RegExps or plain Objects from which the [`PseudoUrl`](../api/pseudo-url)s can be constructed.++ The plain objects must include at least the `purl` property, which holds the pseudo-URL string or RegExp. All remaining keys will be used as the+ `requestTemplate` argument of the [`PseudoUrl`](../api/pseudo-url) constructor, which lets you specify special properties for the enqueued+ [`Request`](../api/request) objects.++ If `pseudoUrls` is an empty array, `null` or `undefined`, then the function enqueues all links found on the page.++ - **`[transformRequestFunction]`**: [`RequestTransform`](../typedefs/request-transform) - Just before a new [`Request`](../api/request) is+ constructed and enqueued to the [`RequestQueue`](../api/request-queue), this function can be used to remove it or modify its contents such as+ `userData`, `payload` or, most importantly `uniqueKey`. This is useful when you need to enqueue multiple `Requests` to the queue that share+ the same URL, but differ in methods or payloads, or to dynamically update or create `userData`.++ For example: by adding `keepUrlFragment: true` to the `request` object, URL fragments will not be removed when `uniqueKey` is computed.++ **Example:**++ ```javascript+ {+ transformRequestFunction: request => {+ request.userData.foo = 'bar';+ request.keepUrlFragment = true;+ return request;+ };+ }+ ```++**Returns**:++[`Promise<Array<QueueOperationInfo>>`](../typedefs/queue-operation-info) - Promise that resolves to an array of+[`QueueOperationInfo`](../typedefs/queue-operation-info) objects.++---++<a name="requestasbrowser"></a>++## `utils.requestAsBrowser(options)`++**IMPORTANT:** This function uses an insecure version of HTTP parser by default and also ignores SSL/TLS errors. This is very useful in scraping,+because it allows bypassing certain anti-scraping walls, but it also exposes some vulnerability. For other than scraping scenarios, please set+`useInsecureHttpParser: false` and `ignoreSslErrors: false`.++Sends a HTTP request that looks like a request sent by a web browser, fully emulating browser's HTTP headers. It uses HTTP2 by default for Node 12+.++This function is useful for web scraping of websites that send the full HTML in the first response. Thanks to this function, the target web server has+no simple way to find out the request hasn't been sent by a human's web browser. Using a headless browser for such requests is an order of magnitude+more resource-intensive than this function.++The function emulates the Chrome and Firefox web browsers. If you want more control over the browsers and their versions, use the+`headerGeneratorOptions` property. You can find more info in the readme of the [`header-generator`](https://github.com/apify/header-generator)+library.++Internally, the function uses the [`got-scraping`](https://github.com/apify/got-scraping) library to perform the request. All `options` not recognized+by this function are passed to it so see it for more details.++**Example usage:**++```js+const Apify = require('apify');++const { utils: { requestAsBrowser } } = Apify;++...++const response = await requestAsBrowser({ url: 'https://www.example.com/' });++const html = response.body;+const status = response.statusCode;+const contentType = response.headers['content-type'];+```++**Parameters**:++- **`options`**: [`RequestAsBrowserOptions`](../typedefs/request-as-browser-options) - All `requestAsBrowser` configuration options.++**Returns**:++[`Promise<RequestAsBrowserResult>`](../typedefs/request-as-browser-result) - The result can be various objects, but it will always be like a+[Node.js HTTP response stream](https://nodejs.org/api/http.html#http_class_http_incomingmessage) with a 'body' property for the parsed response body,+unless the 'stream' option is used.++---++<a name="isdocker"></a>++## `utils.isDocker(forceReset)`++Returns a `Promise` that resolves to true if the code is running in a Docker container.++**Parameters**:++- **`forceReset`**: `boolean`++**Returns**:++`Promise<boolean>`++---++<a name="sleep"></a>++## `utils.sleep(millis)`++Returns a `Promise` that resolves after a specific period of time. This is useful to implement waiting in your code, e.g. to prevent overloading of+target website or to avoid bot detection.++**Example usage:**++```+const Apify = require('apify');++...++// Sleep 1.5 seconds+await Apify.utils.sleep(1500);+```++**Parameters**:++- **`millis`**: `number` - Period of time to sleep, in milliseconds. If not a positive number, the returned promise resolves immediately.++**Returns**:++`Promise<void>`++---++<a name="downloadlistofurls"></a>++## `utils.downloadListOfUrls(options)`++Returns a promise that resolves to an array of urls parsed from the resource available at the provided url. Optionally, custom regular expression and+encoding may be provided.++**Parameters**:++- **`options`**: `object`+ - **`url`**: `string` - URL to the file+ - **`[encoding]`**: `string` <code> = "'utf8'"</code> - The encoding of the file.+ - **`[urlRegExp]`**: `RegExp` <code> = URL_NO_COMMAS_REGEX</code> - Custom regular expression to identify the URLs in the file to extract. The+ regular expression should be case-insensitive and have global flag set (i.e. `/something/gi`).++**Returns**:++`Promise<Array<string>>`++---++<a name="extracturls"></a>++## `utils.extractUrls(options)`++Collects all URLs in an arbitrary string to an array, optionally using a custom regular expression.++**Parameters**:++- **`options`**: `object`+ - **`string`**: `string`+ - **`[urlRegExp]`**: `RegExp` <code> = Apify.utils.URL_NO_COMMAS_REGEX</code>++**Returns**:++`Array<string>`++---++<a name="htmltotext"></a>++## `utils.htmlToText(html)`++The function converts a HTML document to a plain text.++The plain text generated by the function is similar to a text captured by pressing Ctrl+A and Ctrl+C on a page when loaded in a web browser. The+function doesn't aspire to preserve the formatting or to be perfectly correct with respect to HTML specifications. However, it attempts to generate+newlines and whitespaces in and around HTML elements to avoid merging distinct parts of text and thus enable extraction of data from the text (e.g.+phone numbers).++**Example usage**++```javascript+const text = htmlToText('<html><body>Some text</body></html>');+console.log(text);+```++Note that the function uses [cheerio](https://www.npmjs.com/package/cheerio) to parse the HTML. Optionally, to avoid duplicate parsing of HTML and+thus improve performance, you can pass an existing Cheerio object to the function instead of the HTML text. The HTML should be parsed with the+`decodeEntities` option set to `true`. For example:++```javascript+const cheerio = require('cheerio');+const html = '<html><body>Some text</body></html>';+const text = htmlToText(cheerio.load(html, { decodeEntities: true }));+```++**Parameters**:++- **`html`**: `string` | `cheerio.Root` - HTML text or parsed HTML represented using a [cheerio](https://www.npmjs.com/package/cheerio) function.++**Returns**:++`string` - Plain text++---diff --git a/website/versioned_docs/version-1.2.0/examples/use_stealth_mode.md b/website/versioned_docs/version-1.2.0/examples/use_stealth_mode.mdnew file mode 100644index 000000000..e4d8ee5b9--- /dev/null+++ b/website/versioned_docs/version-1.2.0/examples/use_stealth_mode.md@@ -0,0 +1,72 @@+---+id: version-1.2.0-use-stealth-mode+title: Use stealth mode+original_id: use-stealth-mode+---++Stealth mode allows you to bypass anti-scraping techniques that use+[browser fingerprinting](https://pixelprivacy.com/resources/browser-fingerprinting/). It overrides the attributes specified for+[headless](https://developers.google.com/web/updates/2017/04/headless-chrome) browser mode, making your headless browser harder to distinguish from+the full Chrome browser.++To activate stealth mode, you need to `useChrome`, run `headless` and turn `stealth` on in your+[`launchContext`](https://sdk.apify.com/docs/typedefs/puppeteer-crawler-options#launchcontext).++```js+const launchContext = {+ useChrome: true,+ stealth: true,+ launchOptions: {+ headless: true,+ },+};+```++```javascript+const Apify = require('apify');++Apify.main(async () => {+ const requestList = await Apify.openRequestList('start-urls', ['https://news.ycombinator.com/']);++ const crawler = new Apify.PuppeteerCrawler({+ requestList,+ launchContext: {+ useChrome: true,+ stealth: true,+ launchOptions: {+ headless: true,+ },+ // You can override default stealth options+ // stealthOptions: {+ // addLanguage: false,+ // },+ },+ handlePageFunction: async ({ page }) => {+ const data = await page.$$eval('.athing', $posts => {+ const scrapedData = [];+ // Get the title of each post on Hacker News+ $posts.forEach($post => {+ const title = $post.querySelector('.title a').innerText;+ scrapedData.push({+ title: `The title is: ${title}`,+ });+ });+ return scrapedData;+ });+ // Save the data array to the Apify dataSet+ await Apify.pushData(data);+ },+ });+ await crawler.run();+});+```++You can then specify the [`stealthOptions`](https://sdk.apify.com/docs/typedefs/stealth-options), which allow you to adapt to different anti-scraping+techniques. All the options are set to `true` by default. The number of options does not affect performance.++While the default configuration will be fine in many cases, you can adapt the options to your use case.++### Single-browser instances++You can also use stealth mode in single-browser instances when using [`Apify.launchPuppeteer`](https://sdk.apify.com/docs/api/apify#launchpuppeteer).+The `launchContext` is the same.diff --git a/website/versioned_docs/version-1.2.0/guides/docker_images.md b/website/versioned_docs/version-1.2.0/guides/docker_images.mdnew file mode 100644index 000000000..531b3a3fd--- /dev/null+++ b/website/versioned_docs/version-1.2.0/guides/docker_images.md@@ -0,0 +1,181 @@+---+id: version-1.2.0-docker-images+title: Running in Docker+original_id: docker-images+---++Running headless browsers in Docker requires a lot of setup to do it right. But you don't need to worry about that, because we already did it for you and created base images that you can freely use. We use them every day on the [Apify Platform](../guides/apify_platform.md).++All images can be found in their [GitHub repo](https://github.com/apify/apify-actor-docker) and in our [DockerHub](https://hub.docker.com/orgs/apify).++## Overview+Browsers are pretty big, so we try to provide a wide variety of images to suit your needs. Here's a full list of our Docker images.++- [`apify/actor-node`](#actor-node)+- [`apify/actor-node-puppeteer-chrome`](#actor-node-puppeteer-chrome)+- [`apify/actor-node-playwright`](#actor-node-playwright)+- [`apify/actor-node-playwright-chrome`](#actor-node-playwright-chrome)+- [`apify/actor-node-playwright-firefox`](#actor-node-playwright-firefox)+- [`apify/actor-node-playwright-webkit`](#actor-node-playwright-webkit)++## Example Dockerfile+To use our images, you need a [`Dockerfile`](https://docs.docker.com/engine/reference/builder/). You can either use this example, or bootstrap your projects with the [Apify CLI](../guides/getting_started.md#creating-a-new-project) which automatically copies the correct Dockerfile into your project folder.++```dockerfile+# First, specify the base Docker image. You can read more about+# the available images at https://sdk.apify.com/docs/guides/docker-images+# You can also use any other image from Docker Hub.+# The 16 represents the version of Node.js you want to use.+FROM apify/actor-node:16++# Second, copy just package.json and package-lock.json since it should be+# the only file that affects "npm install" in the next step, to speed up the build+COPY package*.json ./++# Install NPM packages, skip optional and development dependencies to+# keep the image small. Avoid logging too much and print the dependency+# tree for debugging+RUN npm --quiet set progress=false \+ && npm install --only=prod --no-optional \+ && echo "Installed NPM packages:" \+ && (npm list || true) \+ && echo "Node.js version:" \+ && node --version \+ && echo "NPM version:" \+ && npm --version++# Next, copy the remaining files and directories with the source code.+# Since we do this after NPM install, quick build will be really fast+# for most source file changes.+COPY . ./++# Optionally, specify how to launch the source code of your actor.+# By default, Apify's base Docker images define the CMD instruction+# that runs the Node.js source code using the command specified+# in the "scripts.start" section of the package.json file.+# In short, the instruction looks something like this:+#+# CMD npm start+```++## Versioning+Each image is tagged with up to 2 version tags, depending on the type of the image. One for Node.js version and second for pre-installed web automation library version. If you use the image name without a version tag, you'll always get the latest available version.++> We recommend always using at least the Node.js version tag in your production Dockerfiles. It will ensure that a future update of Node.js will not break your automations.++### Node.js versioning+Our images are built with multiple Node.js versions to ensure backwards compatibility. Currently, Node.js versions 14, 15 and 16 are supported. To select the preferred version, use the appropriate number as the image tag.++```dockerfile+# Use Node.js 14+FROM apify/actor-node:14+# Use Node.js 16+FROM apify/actor-node-playwright:16+```++### Automation library versioning+Images that include a pre-installed automation library, which means all images that include `puppeteer` or `playwright` in their name, are also tagged with the pre-installed version of the library. For example, `apify/actor-node-puppeteer-chrome:16-8.0.0` comes with Node.js 16 and Puppeteer v8.0.0. If you try to install a different version of Puppeteer into this image, you may run into compatibility issues, because the Chromium version bundled with `puppeteer` will not match the version of Chrome we pre-installed.++Similarly `apify/actor-node-playwright-firefox:14-1.10.0` runs on Node.js 14 and is pre-installed with the Firefox version that comes with v1.10.0.++Installing `apify/actor-node-puppeteer-chrome` (without a tag) will install the latest available version of Node.js and `puppeteer`.++### Pre-release tags+We also build pre-release versions of the images to test the changes we make. Those are typically denoted by a `beta` suffix, but it can vary depending on our needs. If you need to try a pre-release version, you can do it like this:++```dockerfile+# Without library version.+FROM apify/actor-node:16-beta+# With library version.+FROM apify/actor-node-playwright-chrome:16-1.10.0-beta+```++## Best practices+- **Always** use Node.js version tag.+- For **added security**, use the automation library version tag.+- Use asterisk `*` as the automation library version in your `package.json` files.++It makes sure the pre-installed version of Puppeteer or Playwright is not reinstalled on build. This is important, because those libraries are only guaranteed to work with specific versions of browsers, and those browsers come pre-installed in the image.++```dockerfile+FROM apify/actor-node-playwright-chrome:16+```++```json+{+ "dependencies": {+ "apify": "^1.2.0",+ "playwright": "*"+ }+}+```++### Warning about image size+Browsers are huge. If you don't need them all in your image, it's better to use a smaller image with only the one browser you need.++Be careful when installing new dependencies. Nothing prevents you from installing Playwright into the`actor-node-puppeteer-chrome` image, but the resulting image will be about 3 times larger and extremely slow to download and build.++Use only what you need, and you'll be rewarded with reasonable build and start times.++## actor-node+This is the smallest image we have based on Alpine Linux. It does not include any browsers, and it's therefore+best used with [`CheerioCrawler`](../api/cheerio-crawler). It benefits from lightning fast builds and container startups.++[`PuppeteerCrawler`](../api/puppeteer-crawler), [`PlaywrightCrawler`](../api/playwright-crawler)+and other browser based features will **NOT** work with this image.++```dockerfile+FROM apify/actor-node:16+```++## actor-node-puppeteer-chrome+This image includes Puppeteer (Chromium) and the Chrome browser. It can be used with+[`CheerioCrawler`](../api/cheerio-crawler) and [`PuppeteerCrawler`](../api/puppeteer-crawler), but **NOT** with+[`PlaywrightCrawler`](../api/playwright-crawler).++The image supports XVFB by default, so you can run both `headless` and `headful` browsers with it.++```dockerfile+FROM apify/actor-node-puppeteer-chrome:16+```++## actor-node-playwright+A very large and slow image that can run all Playwright browsers: Chromium, Chrome, Firefox,+WebKit. Everything is installed. If you need to develop or test with multiple browsers, this is the image to choose,+but in most cases, we suggest using the specialized images below.++```dockerfile+FROM apify/actor-node-playwright:16+```++## actor-node-playwright-chrome+Similar to [`actor-node-puppeteer-chrome`](#actor-node-puppeteer-chrome), but for Playwright. You can run+[`CheerioCrawler`](../api/cheerio-crawler) and [`PlaywrightCrawler`](../api/playwright-crawler),+but **NOT** [`PuppeteerCrawler`](../api/puppeteer-crawler).++It uses the [`PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD`](https://playwright.dev/docs/api/environment-variables/)+environment variable to block installation of more browsers into your images (to keep them small).+If you want more browsers, either choose the [`actor-node-playwright`](#actor-node-playwright) image+or override this env var.++The image supports XVFB by default, so you can run both `headless` and `headful` browsers with it.++```dockerfile+FROM apify/actor-node-playwright-chrome:16+```++## actor-node-playwright-firefox+Same idea as [`actor-node-playwright-chrome`](#actor-node-playwright-chrome), but with Firefox+pre-installed.++```dockerfile+FROM apify/actor-node-playwright-firefox:16+```++## actor-node-playwright-webkit+Same idea as [`actor-node-playwright-chrome`](#actor-node-playwright-chrome), but with WebKit+pre-installed.++```dockerfile+FROM apify/actor-node-playwright-webkit:16+```diff --git a/website/versioned_docs/version-1.2.0/typedefs/RequestAsBrowserOptions.md b/website/versioned_docs/version-1.2.0/typedefs/RequestAsBrowserOptions.mdnew file mode 100644index 000000000..cb23bdd80--- /dev/null+++ b/website/versioned_docs/version-1.2.0/typedefs/RequestAsBrowserOptions.md@@ -0,0 +1,112 @@+---+id: version-1.2.0-request-as-browser-options+title: RequestAsBrowserOptions+original_id: request-as-browser-options+---++<a name="requestasbrowseroptions"></a>++## Properties++### `url`++**Type**: `string`++URL of the target endpoint. Supports both HTTP and HTTPS schemes.++---++### `method`++**Type**: `string` <code> = "\"GET\""</code>++HTTP method.++---++### `headers`++**Type**: `Object<string, string>`++Additional HTTP headers to add. It's only recommended to use this option, with headers that are typically added by websites, such as cookies.+Overriding default browser headers will remove the masking this function provides.++---++### `proxyUrl`++**Type**: `string`++An HTTP proxy to be passed down to the HTTP request. Supports proxy authentication with Basic Auth.++---++### `headerGeneratorOptions`++**Type**: `object`++Configuration to be used for generating correct browser headers. See the [`header-generator`](https://github.com/apify/header-generator) library.++---++### `languageCode`++**Type**: `string` <code> = "en"</code>++Two-letter ISO 639 language code.++---++### `countryCode`++**Type**: `string` <code> = "US"</code>++Two-letter ISO 3166 country code.++---++### `useMobileVersion`++**Type**: `boolean`++If `true`, the function uses User-Agent of a mobile browser.++---++### `ignoreSslErrors`++**Type**: `boolean` <code> = true</code>++If set to true, SSL/TLS certificate errors will be ignored.++---++### `useInsecureHttpParser`++**Type**: `boolean` <code> = true</code>++Node.js' HTTP parser is stricter than parsers used by web browsers, which prevents scraping of websites whose servers do not comply with HTTP specs,+either by accident or due to some anti-scraping protections, causing e.g. the `invalid header value char` error. The `useInsecureHttpParser` option+forces the HTTP parser to ignore certain errors which lets you scrape such websites. However, it will also open your application to some security+vulnerabilities, although the risk should be negligible as these vulnerabilities mainly relate to server applications, not clients. Learn more in this+[blog post](https://snyk.io/blog/node-js-release-fixes-a-critical-http-security-vulnerability/).++---++### `abortFunction`++**Type**: [`AbortFunction`](../typedefs/abort-function)++Function accepts `response` object as a single parameter and should return `true` or `false`. If function returns true, request gets aborted.++---++### `useHttp2`++**Type**: `boolean` <code> = true</code>++If set to false, it will prevent use of HTTP2 requests. This is strongly discouraged. Websites expect HTTP2 connections, because browsers use HTTP2 by+default. It will automatically downgrade to HTTP/1.1 for websites that do not support HTTP2. For Node 10 this option is always set to `false` because+Node 10 does not support HTTP2 very well. Upgrade to Node 12 for better performance.++---diff --git a/website/versions.json b/website/versions.jsonindex 3709dda58..0248cd890 100644--- a/website/versions.json+++ b/website/versions.json@@ -1,4 +1,5 @@[+ "1.2.0","1.1.2","1.1.0","1.0.2",