# Ana White Furniture Plans Scraper (`automation-lab/ana-white-furniture-plans-scraper`) Actor

Search Ana White furniture plans and export materials, tools, cut lists, build steps, images, and source URLs.

- **URL**: https://apify.com/automation-lab/ana-white-furniture-plans-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.88 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Ana White Furniture Plans Scraper

Build a searchable catalog of **Ana White furniture plans** with structured materials, tools, cut lists, dimensions, build steps, images, and canonical source URLs.

Search by project name, process a category, or extract one known plan URL. Each dataset row represents one complete public project plan, ready for a spreadsheet, database, or research pipeline.

### What does this Actor do?

The Actor turns public Ana White DIY plan pages into consistent JSON records.

It can:

- search plan titles such as `adirondack chair`;
- browse the newest project catalog;
- paginate a supported Ana White category URL;
- extract one or more supplied project URLs;
- collect project metadata and requirements;
- preserve ordered step summaries and diagram links;
- return canonical links for source attribution.

The Actor uses lightweight server-rendered pages. It does not download images or PDFs, so runs remain fast and compact.

### Who is it for?

Use this Actor if you are:

- a woodworker comparing lumber and tool requirements;
- a researcher cataloging Ana White DIY projects;
- a content or data team organizing furniture-plan metadata;
- an educator preparing a searchable project index;
- a developer feeding plan records into an app or data pipeline;
- an operations team scheduling periodic catalog snapshots.

It is designed for structured cataloging, not for rendering printable plans or reproducing the source website.

### Why use this Ana White plans extractor?

A generic page-text scraper returns one large block of text.

This Actor separates useful project concepts into stable fields:

- title and summary;
- difficulty, project type, and room;
- dimensions and dimension diagrams;
- materials and shopping-list entries;
- tools;
- cut-list sections;
- cutting and general instructions;
- ordered build steps;
- project, diagram, and step images;
- PDF link when exposed;
- canonical source URL.

That structure makes projects easier to filter, compare, and export.

### What data can I extract?

| Field | Meaning |
| --- | --- |
| `title` | Project-plan title |
| `summary` | Source overview of the project |
| `difficulty` | Difficulty label when present |
| `categories` | Project-type categories |
| `rooms` | Room or placement categories |
| `dimensions` | Text accompanying the dimension diagram |
| `dimensionImages` | URLs of dimension diagrams |
| `materials` | Shopping-list or material sections |
| `tools` | Tool names identified by the plan |
| `cutList` | Cut-list entries or sections |
| `cuttingInstructions` | General cutting guidance |
| `generalInstructions` | General assembly guidance |
| `steps` | Ordered step numbers, summaries, and diagram URLs |
| `images` | Deduplicated finished, dimension, and step images |
| `pdfUrl` | Plan PDF link when available |
| `canonicalUrl` | Canonical Ana White source URL |
| `scrapedAt` | Extraction timestamp in ISO 8601 format |

Fields can be empty when a source plan does not publish that section.

### How to scrape Ana White furniture plans

1. Open the Actor in Apify Console.
2. Enter a title query, such as `farmhouse table`.
3. Optionally add specific plan or category URLs.
4. Choose the maximum number of plans.
5. Click **Start**.
6. Open the **Dataset** tab.
7. Export results as JSON, CSV, Excel, XML, or another supported format.

Start with a small `maxItems` value while testing a workflow.

### Input parameters

#### `query`

Optional title search, up to 200 characters.

Examples:

- `adirondack chair`
- `farmhouse table`
- `chicken coop`
- `planter box`

Leave it blank to browse the newest plans when no URLs are supplied.

#### `startUrls`

Optional list of public `ana-white.com` woodworking URLs.

Supported URL types:

- an individual `/woodworking-projects/...` plan;
- the main `/woodworking-projects` catalog;
- a supported category, skill-level, seasonal, or holiday listing.

Other hosts and unrelated Ana White paths fail validation.

#### `maxItems`

Maximum complete plan records to save.

- Default: `20`
- Minimum: `1`
- Maximum: `10000`

#### `maxPages`

Maximum catalog pages inspected for each discovery URL.

- Default: `10`
- Minimum: `1`
- Maximum: `100`

Direct plan URLs do not need pagination.

### Input examples

Search for Ana White Adirondack chair plans:

```json
{
  "query": "adirondack chair",
  "maxItems": 5,
  "maxPages": 2
}
```

Extract one known plan:

```json
{
  "startUrls": [
    {
      "url": "https://www.ana-white.com/woodworking-projects/farmhouse-table-updated-pocket-hole-plans"
    }
  ],
  "maxItems": 1,
  "maxPages": 1
}
```

Build an outdoor-seating catalog:

```json
{
  "startUrls": [
    {
      "url": "https://www.ana-white.com/woodworking-projects/categories/outdoor-projects/outdoor-seating-lounging-and-accents"
    }
  ],
  "maxItems": 10,
  "maxPages": 3
}
```

### Output example

A current project record has this shape:

```json
{
  "title": "Modern Easy Build Adirondack Chair",
  "summary": "Build the most popular—and most built—Adirondack chair plans on the internet with this modern, easy-to-follow design.",
  "difficulty": "Intermediate",
  "categories": ["Outdoor Seating, Lounging and Accents"],
  "rooms": ["Outdoor"],
  "dimensions": "Dimensions shown in diagram for modern Adirondack chair",
  "dimensionImages": [
    "https://www.ana-white.com/sites/default/files/images/2x4%20modern%20adirondack%20chair%20dimensions.jpg"
  ],
  "materials": ["3 - 2x4 @ 104-5/8 inches long"],
  "tools": ["Tape Measure", "Speed Square", "Circular Saw"],
  "cutList": ["5 - 2x4 @ 19-1/2 inches - legs and horizontal supports"],
  "cuttingInstructions": "It may be easier to pre-finish your boards before cutting.",
  "generalInstructions": "Work on a flat level surface.",
  "steps": [
    {
      "number": 1,
      "summary": "Cut the chair stringers and build the arms with exterior screws and wood glue.",
      "imageUrl": "https://www.ana-white.com/sites/default/files/2020-04/2x4%20modern%20adirondack%20chair%20step%201.jpg"
    }
  ],
  "images": [
    "https://www.ana-white.com/sites/default/files/ana%20white%20adirondack%20chair%20plans.png"
  ],
  "pdfUrl": null,
  "canonicalUrl": "https://www.ana-white.com/woodworking-projects/modern-easy-build-adirondack-chair",
  "scrapedAt": "2026-08-31T12:00:00.000Z"
}
```

The complete row includes every available material, tool, cut, step, and image.

### How much does it cost to scrape Ana White furniture plans?

The Actor uses pay-per-event pricing:

- **$0.005** once per run for the `start` event;
- **$0.0048 per saved plan** on the BRONZE tier for the `item` event.

Approximate BRONZE-tier examples:

| Saved plans | BRONZE-tier charge calculation |
| ---: | --- |
| 1 | one $0.005 start event + one $0.0048 item event |
| 5 | one $0.005 start event + five $0.0048 item events |
| 10 | one $0.005 start event + ten $0.0048 item events |
| 100 | one $0.005 start event + one hundred $0.0048 item events |

Failed, duplicate, or rejected pages are not charged as items. Subscription tiers apply progressively lower per-plan prices. Apify shows the applicable price before a run.

### Search, catalog, and direct-URL behavior

A query is sent through Ana White's public title filter.

Catalog and category pages are paginated until:

- `maxItems` is reached;
- `maxPages` is reached;
- no new plan links remain; or
- the source has no more results.

Every discovered project is then opened to collect complete detail fields.

Supplied detail URLs are processed directly and deduplicated by canonical URL.

If both a query and URLs are supplied, direct URLs are processed first and matching catalog results can fill the remaining limit.

### Reliability and error handling

The Actor validates status codes, content type, page shape, and supported hosts.

Temporary timeouts, connection failures, HTTP 429 responses, and temporary server errors receive bounded retries with backoff.

The run fails instead of returning misleading empty records when:

- a supplied URL is malformed;
- a URL belongs to another domain;
- a stable 404 is returned;
- a detail URL is not a woodworking plan;
- Ana White returns an unrecognized challenge page;
- a required plan title cannot be parsed.

A legitimate search with no matches succeeds with an empty dataset.

### Tips and limitations

- Search uses title matching exposed by the source, not full semantic search.
- Source plans vary, so some optional fields are empty.
- `dimensions` may describe an image rather than contain numeric measurements.
- Images and PDFs are linked, not downloaded into Actor storage.
- The Actor processes public English-language Ana White pages.
- It does not extract comments, user accounts, or community-project submissions.
- It does not track historical changes by itself; schedule repeated runs and compare datasets in your own workflow.
- Very large runs depend on the current size and availability of the public catalog.

### Export and integration workflows

Common workflows include:

1. **Spreadsheet catalog** — export CSV or Excel and filter projects by room, difficulty, or tools.
2. **Material comparison** — normalize `materials` and `cutList` in a downstream script.
3. **Project search index** — store titles, summaries, and canonical URLs in a database.
4. **Recurring snapshot** — schedule the Actor and compare canonical URLs between runs.
5. **Content research** — review step counts and project categories while preserving source attribution.
6. **Data pipeline** — use the dataset API from Make, Zapier, n8n, or custom code.

The default dataset remains isolated per run.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ana-white-furniture-plans-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"adirondack chair","maxItems":5,"maxPages":2}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ana-white-furniture-plans-scraper').call({
    query: 'adirondack chair',
    maxItems: 5,
    maxPages: 2,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/ana-white-furniture-plans-scraper").call(
    run_input={
        "query": "adirondack chair",
        "maxItems": 5,
        "maxPages": 2,
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/ana-white-furniture-plans-scraper"
```

**Claude Desktop setup:** add this server object to your MCP configuration.

**Cursor setup:** open MCP settings and add the same HTTP server object.

**VS Code setup:** add the same server under your MCP servers configuration.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/ana-white-furniture-plans-scraper"
    }
  }
}
```

Example prompts:

- “Find five Ana White Adirondack chair plans and compare their material lists.”
- “Extract this Ana White farmhouse table URL and summarize the tools and cuts.”
- “Build a dataset of outdoor seating plans with source links and step counts.”

### Legality and responsible use

This Actor reads publicly accessible pages.

You are responsible for:

- complying with Ana White's terms and applicable laws;
- using reasonable run sizes and schedules;
- respecting copyright and source attribution;
- avoiding republication of protected plan content without permission;
- handling exported data according to your organization's policies.

The Actor does not bypass login controls or collect private account data.

### Troubleshooting

#### Why did my search return no rows?

Try a shorter title phrase, verify spelling, and test the same phrase on the public catalog. A valid no-match query returns an empty dataset.

#### Why did a start URL fail?

Confirm that it uses `https://www.ana-white.com/woodworking-projects...`. Blog, community, account, and third-party URLs are intentionally rejected.

#### Why are some material or dimension fields empty?

Older and newer plan templates publish different sections. Empty optional fields reflect the source page rather than invented values.

#### How can I reduce run time?

Lower `maxItems` and `maxPages`, or provide direct plan URLs when you already know the projects you need.

### FAQ

#### Can it scrape Ana White DIY plan categories?

Yes. Supply a supported woodworking category URL and the Actor discovers and enriches project pages up to your limits.

#### Can it extract Ana White free plans?

It extracts public woodworking project pages reachable without authentication. Availability and licensing remain determined by the source.

#### Does it download plan images or PDFs?

No. It returns absolute URLs, which keeps the dataset lightweight.

#### Can I schedule monitoring?

Yes. Use an Apify Schedule and compare each run's canonical URLs or field values downstream. The Actor itself does not maintain a historical database or send alerts.

#### Are comments included?

No. The output focuses on project-plan data and excludes comments and user profiles.

#### Is a proxy required?

No automatic proxy mode is enabled. Current public pages are available through direct server-rendered HTML.

### Related Automation Lab Actors

For broader website extraction, consider:

- [Website Content Crawler](https://apify.com/automation-lab/website-content-crawler) for general multi-page text collection;
- [Website Screenshot Generator](https://apify.com/automation-lab/website-screenshot-generator) when a visual page capture is the required output.

Use this Actor when you need Ana White-specific project structure rather than generic page content.

# Actor input Schema

## `query` (type: `string`):

Words to match in plan titles, such as adirondack chair, farmhouse table, or chicken coop. Leave blank to browse the newest plans.

## `startUrls` (type: `array`):

Optional ana-white.com woodworking plan, category, or catalog URLs. Specific plan URLs are extracted directly; catalog URLs are discovered and paginated.

## `maxItems` (type: `integer`):

Maximum number of complete project-plan records to save.

## `maxPages` (type: `integer`):

Maximum number of catalog result pages to inspect per query or catalog URL.

## Actor input object example

```json
{
  "query": "adirondack chair",
  "startUrls": [],
  "maxItems": 20,
  "maxPages": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Complete project-plan records with metadata, requirements, steps, media, and canonical source URLs.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "adirondack chair",
    "startUrls": [],
    "maxItems": 20,
    "maxPages": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ana-white-furniture-plans-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "adirondack chair",
    "startUrls": [],
    "maxItems": 20,
    "maxPages": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ana-white-furniture-plans-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "adirondack chair",
  "startUrls": [],
  "maxItems": 20,
  "maxPages": 10
}' |
apify call automation-lab/ana-white-furniture-plans-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ana-white-furniture-plans-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/X6md1DxxEHZT3AgqF/builds/etdw7UiPgmTn5AFn1/openapi.json