[ Docs ](https://yore.steddle.com/docs) [ Getting started ](https://yore.steddle.com/docs/getting-started) Make a plan =========== Name a website, choose its paths, languages and years, read the archive's index, tick the pages and fetch them. 01 Getting started --------------- Article 2 of 3 A plan is how Yore reads one website: its domains, the paths to follow, the languages, a window of time, and how many captures of each page to fetch. An account holds 3 plans, and a plan holds 1.000 ticked pages. Name the website ---------------- Choose **New plan** and type the domain, `tesla.com`. If the site lived on another domain before, add it after a comma: `tesla.com, teslamotors.com`. A plan takes five domains at most. Give the first and last day you want to see, or leave them empty for everything the archive holds. Yore then reads what the site lists of itself: its sitemaps today, the archive's copy of them where the site refuses Yore, and the archive's copies from earlier years. Those older sitemaps are how pages that are gone today show up. Choose paths and languages -------------------------- Under **Rules**, the list **What the site holds** shows the site as a tree: each path with how many pages lie under it. Open a path to look inside it. **Follow** adds that one page, and **Follow all under it** adds every page that starts with it. Above the tree, **Follow the home page** adds `/` and **Follow the whole site** adds `/*`. You can also type a path by hand. The archive's index often knows pages no sitemap lists. - **Paths.** A path is one page: `/` is the home page, `/about` that page. A path that ends in `*` is every page that starts with it: `/model3*` takes `/model3`, `/model3/design` and `/model3-performance`, and `/*` is the whole site. A page followed by itself comes without its variants that carry a query string. - **Languages.** Yore reads a language from the start of a path, `/nl_nl/model3` or `/en-gb/pricing`. Tick the ones you want. With none ticked, Yore reads every language it knows for the site, and the pages with no language in their path. - **How many captures.** Every distinct capture, one a week, or one a month. A page that changes on every load has a different capture each time the archive visits. One a month keeps such a page to a dozen fetches a year. Yore always fetches a page's last capture in the window too. Read the archive's index ------------------------ **Save and read the archive** asks the archive's index for every page your paths name, in each language, and for every capture of each page: its time, the status the site answered with, and a digest of what the archive stored. That includes captures of a 404 and of a redirect, which is how Yore sees a removal. It costs one request or a few per path and language and runs in the background. An address the archive only ever saw refuse, such as a probe for `/.well-known/nodeinfo`, is left off the plan unless a sitemap names it: there is nothing to read on it. Scripts, stylesheets, images and videos are left off too. Reading a site, reading the index and fetching all run in the background. If a plan is busy and Yore hasn't heard from its job for 15 minutes, the plan says so and offers **Start again**. What was already read is kept. Once the index is read, **Save** applies what you changed and nothing else. A path or language you take away takes its pages off the plan at once, without a request to the archive. One you add is read from the archive's index in the background, while the plan's other pages stay in view and in use. **Save and read the archive again** also asks the archive what it captured since, for every path it read a day or more ago. While Yore reads the index or fetches, the rules are closed. A plan that fetches opens them once you pause it. If the archive holds more under a path than Yore reads in one go, the plan says so and asks you to narrow the path. Tick the pages -------------- Every page the index knows under your rules is on the plan, ticked. Untick what you don't need. Only ticked pages are fetched, compared and exported. You can search by address, filter by language, show only pages the archive records as removed or redirected, and sort by the number of captures. With a filter on, the menu beside the list ticks or unticks every page that matches. Past 1.000 pages, the pages with the fewest captures lose their tick. See what a run costs -------------------- **Coverage** states, before anything is fetched: the ticked pages, the captures in the window, the distinct captures to read, how many of those Yore already holds, how many requests remain, and how long that takes at the archive's pace. A bar per year shows how densely the archive covers the window. A capture another plan fetched before costs nothing: Yore keeps every capture once, under the hash of its bytes. Fetch ----- **Fetch** starts the run. Yore makes one request every 1,5 seconds, about 40 a minute, for every plan together. Plans take turns, one request each, so a large plan never holds a small one up. You can pause a run and resume it. When the pages are in, Yore derives each one's text, groups a page's captures into [versions](https://yore.steddle.com/docs/getting-started/read-a-page), reads [removals](https://yore.steddle.com/docs/evidence/what-a-capture-proves#removals) from the archive's record, and then fetches the images of each version, 40 a version at most. A capture the archive refuses three times is given up on, and the run moves on. A busy plan states where it stands under its name, on every tab and on its row in the list of plans: the step it is on, how much of it is done, and how long the rest takes at the archive's pace. A run that took ten minutes or more ends with a mail to the plan's owner, when it is done and when it stopped before that. Checked against the code on 1 October 2026. [ What Yore is ](https://yore.steddle.com/docs/getting-started/what-yore-is) [ Read a page ](https://yore.steddle.com/docs/getting-started/read-a-page)