# LocalHarvest Scraper - Farms, Farmers Markets & CSAs (`crawlerbros/localharvest-scraper`) Actor

Scrape LocalHarvest.org: farms, farmers markets, CSAs, U-Pick, and farm stands. Search by location and type, or fetch listings by URL. Get addresses, coordinates, products, contact info, and ratings.

- **URL**: https://apify.com/crawlerbros/localharvest-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## LocalHarvest Scraper - Farms, Farmers Markets & CSAs

Scrape **LocalHarvest.org** — the largest US directory of farms, farmers markets, CSAs (Community Supported Agriculture), U-Pick farms, farm stands, and other local food sources. Search any location and listing type and get names, addresses, GPS coordinates, descriptions, products/crops, ratings, and contact info. Optionally follow through to each listing's full profile page for phone, website, social links, farming practices, CSA share details, and market schedules. No login, no cookies, no API key required.

### What this actor does

- **Two modes:** `search` (location + listing type + keyword) and `byUrl` (direct listing profile URLs)
- **9 listing types** — Farms, Farmers Markets, CSA, U-Pick / Pick-your-own, Farm Stands, Wholesale, Restaurants (farm-to-table), Groceries / Co-ops, and Others — plus "All types"
- **Search by zip code, city + state, or full state name** — or pick any of the 50 US states + DC from a dropdown
- **Free-text keyword search** — find listings by product ("honey", "grass-fed beef"), name, or practice
- **Sort by** relevance, rating, or name (A-Z)
- **Filter by** minimum rating (1-5 stars), SNAP/EBT-accepted only, or Certified Organic only
- **Rich listing profiles** — phone, website, Facebook/Instagram/Twitter/YouTube links, full street address, products & crops by season, farming practices, association memberships, CSA share pricing, and farmers-market schedules
- **Precise GPS coordinates** on every search result, read directly from LocalHarvest's own map data
- **Empty fields are omitted** — you only ever see fields that were actually found for a listing

### Output per listing

- `name` — listing name
- `listingId` — LocalHarvest's own numeric listing ID
- `listingType` — general category (Farms / Farmers Markets / CSA / U-Pick / Farm Stands / Wholesale / Restaurants / Groceries / Others)
- `badge` — LocalHarvest's specific listing badge (e.g. "Family Farm", "Community Farm", "Farmers Market")
- `description` — listing description (short snippet in search results; full text when profile fetched)
- `street`, `city`, `state`, `zipCode`
- `latitude`, `longitude` — GPS coordinates (search results)
- `rating` — 1-5 stars, `reviewCount` — number of written reviews (from the listing's own profile page, when it has reviews)
- `snapEbtAccepted`, `isCertifiedOrganic`, `isSupporter` — badges shown on the listing (search results); `isCertifiedOrganic` may also be set from the "Farming Practices" list when a profile is fetched
- `phone`, `website` (when profile fetched)
- `facebookUrl`, `instagramUrl`, `twitterUrl`, `youtubeUrl` — social links the listing has published (when profile fetched)
- `products[]` — products and crops offered, aggregated across all seasons (when profile fetched)
- `practices[]` — farming practices (e.g. "naturally grown", "certified organic") (when profile fetched)
- `associations[]` — association memberships (when profile fetched)
- `marketChannels[]` — how the listing sells (CSA, Farm Stand, Farmers Market, Wholesale...) (when profile fetched)
- `csaSeason`, `csaType`, `csaSince`, `csaNumShares`, `csaSharePrices` — CSA share program details, when the listing offers a CSA (when profile fetched)
- `marketSchedule` — days/hours, for farmers markets and farm stands (when profile fetched)
- `farmStandSchedule` — farm-stand-specific schedule/location notes (when profile fetched)
- `images[]` — listing photo gallery (when profile fetched)
- `nearbyCities[]` — nearby city links LocalHarvest surfaces on the profile (when profile fetched)
- `eventsUrl` — link to upcoming local events for the listing's area (when profile fetched)
- `lastUpdated` — when the listing owner last updated their profile (when profile fetched)
- `imageUrl` — primary listing photo
- `searchType`, `searchLocation`, `searchKeyword` — the search parameters used (mode=search)
- `sourceUrl` — canonical LocalHarvest listing URL
- `recordType: "listing"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `search` | `search` (location + type + keyword) or `byUrl` (fetch by URL) |
| `location` | string | `California` | Zip code, city + state, or state name to search in (mode=search) |
| `state` | string (select) | – | Pick one of the 50 US states + DC, overrides `location` (mode=search) |
| `listingType` | string (select) | `farms` | One of the 9 listing types, or `all` |
| `keyword` | string | – | Free-text keyword (product, name, practice) |
| `minRating` | integer | `0` (no minimum) | Only return listings rated at least 1-5 stars |
| `snapEbtOnly` | boolean | `false` | Only return listings that display LocalHarvest's SNAP/EBT badge |
| `organicOnly` | boolean | `false` | Only return listings that display LocalHarvest's Certified Organic badge |
| `sortBy` | string (select) | `relevance` | `relevance` / `rating` (highest first) / `name` (A-Z) — applied client-side across the fetched batch |
| `fetchDetails` | boolean | `false` | Also visit each listing's profile page for richer data (slower) |
| `listingUrls` | array | – | LocalHarvest listing URLs to fetch directly (mode=byUrl) |
| `maxItems` | int | `20` | Hard cap on returned records (1-500) |

#### Example: farms in California

```json
{
  "mode": "search",
  "state": "California",
  "listingType": "farms",
  "maxItems": 20
}
````

#### Example: farmers markets near a zip code, with full profiles

```json
{
  "mode": "search",
  "location": "50010",
  "listingType": "farmersMarkets",
  "fetchDetails": true,
  "maxItems": 30
}
```

#### Example: highest-rated CSAs in Iowa that accept SNAP/EBT

```json
{
  "mode": "search",
  "state": "Iowa",
  "listingType": "csa",
  "snapEbtOnly": true,
  "sortBy": "rating",
  "maxItems": 50
}
```

#### Example: Certified Organic farms in Oregon

```json
{
  "mode": "search",
  "state": "Oregon",
  "listingType": "farms",
  "organicOnly": true,
  "maxItems": 30
}
```

#### Example: keyword search for honey producers nationwide

```json
{
  "mode": "search",
  "keyword": "honey",
  "listingType": "all",
  "maxItems": 40
}
```

#### Example: fetch specific listing profiles

```json
{
  "mode": "byUrl",
  "listingUrls": [
    { "url": "https://www.localharvest.org/blue-gate-farm-M11943" }
  ]
}
```

### Use cases

- **Local food sourcing** — build a list of farms, CSAs, and markets near a location for personal or business sourcing
- **Market research** — measure the density of farms, CSAs, or farmers markets by state or region
- **Directory aggregation** — feed structured local-food data into your own food-sourcing or farm-to-table product
- **CSA & farmers-market discovery** — compare share pricing, season length, and product offerings across CSAs
- **Nonprofit / food-access research** — filter for SNAP/EBT-accepting listings to map food-access coverage

### Limitations

- **Occasional connectivity slowness to LocalHarvest from Apify's datacenter IPs.** LocalHarvest's servers are sometimes slow to respond to requests from cloud datacenter IP ranges. The actor automatically retries with exponential backoff and rotates through Apify's free AUTO proxy on any failure, and every run in testing eventually succeeded with full results -- but a run may take a few minutes longer than expected during a slow window. No paid proxy tier is used at any point.
- **`latitude`/`longitude` are only available for city/zip-level searches, not statewide searches.** LocalHarvest only embeds precise per-listing coordinates in the page for narrower searches; a statewide search (e.g. `state: "California"`) instead renders an aggregated density heatmap with no per-listing coordinates in the page HTML. Search narrower (a zip code or city name) to get coordinates on every record, or use `fetchDetails`/`mode: "byUrl"` for other listing fields that don't depend on the map.
- **An unrecognized `location` value falls back to LocalHarvest's own IP-based default location** rather than always returning zero results -- this is upstream behavior (confirmed: the same nonsense location string returns "No Results Found" from some client IPs and real nearby listings from others). The actor always returns whatever real data LocalHarvest's own page renders; it never fabricates records.
- **Some `imageUrl`/`images[]` values are served by LocalHarvest's own CDN (`lh-images.us-east-1.linodeobjects.com`) with an inaccurate `Content-Type: application/unknown` header**, even though the response is a genuine JPEG/PNG (verified by file signature). This is an upstream CDN configuration quirk, not a broken link -- the image loads correctly in any browser or image viewer.
- **`sortBy` is applied client-side.** LocalHarvest's search-results pages don't expose a server-side sort parameter, so `rating`/`name` sorting is applied across the batch of records this run actually fetched, not the entire listing type.
- **`minRating` and `snapEbtOnly` are applied client-side.** A listing with no reviews yet is only excluded by `minRating` (which requires a rating to compare against); most listings on LocalHarvest have no reviews, so a high `minRating` will sharply narrow results.
- **Ratings and review counts require at least one review.** LocalHarvest only publishes a listing's structured rating data once it has received a review; listings with none simply omit `rating`/`reviewCount` rather than showing a zero.
- **`ty=5` ("Shop"), Photo Albums, Events, and Products are not exposed as listing types.** These upstream search verticals return online-store items, photo galleries, calendar events, and a crop encyclopedia respectively — not location-based business listings — so they're out of scope for this directory-style actor.
- **CSA share details, market schedules, products, and social links require `fetchDetails: true`** (search mode) or `mode: "byUrl"`. Plain search results include name, type, location, coordinates, description snippet, and badges only.

### FAQ

**What data source does this actor use?**
It reads the publicly available search and listing-profile pages on LocalHarvest.org, the largest US directory of farms, farmers markets, and local food sources. No account or API key is needed.

**Is this affiliated with LocalHarvest?**
No. This is an independent, third-party actor that reads publicly accessible pages.

**Why do some listings have no rating, phone, or products?**
LocalHarvest only shows a rating once a listing has received at least one review, and only shows contact/product details the listing owner has provided. Fields with no data are simply omitted from the record rather than shown as empty or null.

**Can I search a whole state instead of a single city or zip code?**
Yes — set `state` to any of the 50 US states (or DC); it takes priority over `location`. You can also just type a state name (e.g. `"Iowa"`) directly into `location`.

**What's the difference between `listingType` and `badge`?**
`listingType` is the general category this actor searches by (Farms, Farmers Markets, CSA, etc.). `badge` is LocalHarvest's own, more specific label shown on the listing — for farms this is often a sub-type like "Family Farm" or "Community Farm" rather than the plain word "Farms".

**How accurate are the GPS coordinates?**
`latitude`/`longitude` come directly from LocalHarvest's own search-results map data, which is precise to the individual listing (not just its city).

**What's the difference between `snapEbtOnly` and `organicOnly`?**
Both filter on badges LocalHarvest displays on the listing itself: `snapEbtOnly` keeps only listings showing the SNAP/EBT-accepted badge, `organicOnly` keeps only listings showing the Certified Organic badge (from the search-card badge or, when `fetchDetails`/`byUrl` is used, the listing's own "Farming Practices" list). Both can be combined with each other and with `minRating`.

**Why is `fetchDetails` off by default?**
Fetching each listing's full profile page requires one extra request per result, which is slower. Turn it on when you need phone, website, social links, products/crops, farming practices, CSA share details, or market schedules.

**Does this actor need a proxy or login?**
No — LocalHarvest's search and profile pages are served without any anti-bot challenge, so this actor runs entirely on Apify's free plan with no proxy and no credentials required from you (it uses Apify's free AUTO proxy automatically only if the datacenter IP is ever rate-limited).

**What does CSA share pricing (`csaSharePrices`) mean?**
It's the listing's own published pricing for a CSA (Community Supported Agriculture) membership/share, exactly as written on their LocalHarvest profile — format varies by farm (e.g. "$700/season", "$25/week").

# Actor input Schema

## `mode` (type: `string`):

What to fetch: search by location/type/keyword, or fetch full listing profiles from direct LocalHarvest listing URLs.

## `location` (type: `string`):

Where to search: a US zip code (e.g. '50010'), a city and state (e.g. 'Austin, TX'), or a full state name (e.g. 'California'). Overridden by 'US state' below when that is set (mode=search).

## `state` (type: `string`):

Pick a US state to search statewide instead of typing a location. Takes priority over 'Location' when set (mode=search).

## `listingType` (type: `string`):

Which kind of local-food listing to search for (mode=search).

## `keyword` (type: `string`):

Free-text keyword to search for, e.g. a product ('honey', 'organic strawberries'), farm name, or practice ('grass-fed'). Combined with location and listing type when set (mode=search).

## `minRating` (type: `integer`):

Only return listings rated at least this many stars, 1-5 (mode=search). 0 means no minimum. Applied client-side; listings with no reviews yet are excluded once this is set above 0.

## `snapEbtOnly` (type: `boolean`):

Only return listings that display LocalHarvest's SNAP/EBT-accepted badge (mode=search).

## `organicOnly` (type: `boolean`):

Only return listings that display LocalHarvest's Certified Organic badge (mode=search).

## `sortBy` (type: `string`):

How to order search results after fetching (mode=search). LocalHarvest itself returns results ordered by distance/relevance; 'rating' and 'name' are applied client-side across the fetched batch.

## `fetchDetails` (type: `boolean`):

For each search result, also visit its listing profile page to collect phone, website, social links, full description, products/crops, farming practices, associations, and market channel details (CSA share info, market schedule). Slower -- one extra request per result (mode=search).

## `listingUrls` (type: `array`):

Direct LocalHarvest listing URLs to fetch, e.g. https://www.localharvest.org/blue-gate-farm-M11943. Use the 'sourceUrl' field from search results.

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

Hard cap on the number of listing records to return.

## Actor input object example

```json
{
  "mode": "search",
  "location": "California",
  "state": "",
  "listingType": "farms",
  "minRating": 0,
  "snapEbtOnly": false,
  "organicOnly": false,
  "sortBy": "relevance",
  "fetchDetails": false,
  "listingUrls": [],
  "maxItems": 20
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped LocalHarvest listings.

# 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 = {
    "mode": "search",
    "location": "California",
    "state": "",
    "listingType": "farms",
    "minRating": 0,
    "snapEbtOnly": false,
    "organicOnly": false,
    "sortBy": "relevance",
    "fetchDetails": false,
    "listingUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/localharvest-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 = {
    "mode": "search",
    "location": "California",
    "state": "",
    "listingType": "farms",
    "minRating": 0,
    "snapEbtOnly": False,
    "organicOnly": False,
    "sortBy": "relevance",
    "fetchDetails": False,
    "listingUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/localharvest-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "search",
  "location": "California",
  "state": "",
  "listingType": "farms",
  "minRating": 0,
  "snapEbtOnly": false,
  "organicOnly": false,
  "sortBy": "relevance",
  "fetchDetails": false,
  "listingUrls": [],
  "maxItems": 20
}' |
apify call crawlerbros/localharvest-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/localharvest-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LocalHarvest Scraper - Farms, Farmers Markets & CSAs",
        "description": "Scrape LocalHarvest.org: farms, farmers markets, CSAs, U-Pick, and farm stands. Search by location and type, or fetch listings by URL. Get addresses, coordinates, products, contact info, and ratings.",
        "version": "1.0",
        "x-build-id": "1uKk3hSKEFD6ng4hW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~localharvest-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-localharvest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~localharvest-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-localharvest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~localharvest-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-localharvest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch: search by location/type/keyword, or fetch full listing profiles from direct LocalHarvest listing URLs.",
                        "default": "search"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search: a US zip code (e.g. '50010'), a city and state (e.g. 'Austin, TX'), or a full state name (e.g. 'California'). Overridden by 'US state' below when that is set (mode=search).",
                        "default": "California"
                    },
                    "state": {
                        "title": "US state (overrides Location above)",
                        "enum": [
                            "",
                            "Alabama",
                            "Alaska",
                            "Arizona",
                            "Arkansas",
                            "California",
                            "Colorado",
                            "Connecticut",
                            "Delaware",
                            "Florida",
                            "Georgia",
                            "Hawaii",
                            "Idaho",
                            "Illinois",
                            "Indiana",
                            "Iowa",
                            "Kansas",
                            "Kentucky",
                            "Louisiana",
                            "Maine",
                            "Maryland",
                            "Massachusetts",
                            "Michigan",
                            "Minnesota",
                            "Mississippi",
                            "Missouri",
                            "Montana",
                            "Nebraska",
                            "Nevada",
                            "New Hampshire",
                            "New Jersey",
                            "New Mexico",
                            "New York",
                            "North Carolina",
                            "North Dakota",
                            "Ohio",
                            "Oklahoma",
                            "Oregon",
                            "Pennsylvania",
                            "Rhode Island",
                            "South Carolina",
                            "South Dakota",
                            "Tennessee",
                            "Texas",
                            "Utah",
                            "Vermont",
                            "Virginia",
                            "Washington",
                            "West Virginia",
                            "Wisconsin",
                            "Wyoming",
                            "District of Columbia"
                        ],
                        "type": "string",
                        "description": "Pick a US state to search statewide instead of typing a location. Takes priority over 'Location' when set (mode=search).",
                        "default": ""
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "all",
                            "farms",
                            "farmersMarkets",
                            "csa",
                            "upick",
                            "farmStands",
                            "wholesale",
                            "restaurants",
                            "groceries",
                            "others"
                        ],
                        "type": "string",
                        "description": "Which kind of local-food listing to search for (mode=search).",
                        "default": "farms"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text keyword to search for, e.g. a product ('honey', 'organic strawberries'), farm name, or practice ('grass-fed'). Combined with location and listing type when set (mode=search)."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return listings rated at least this many stars, 1-5 (mode=search). 0 means no minimum. Applied client-side; listings with no reviews yet are excluded once this is set above 0.",
                        "default": 0
                    },
                    "snapEbtOnly": {
                        "title": "SNAP/EBT accepted only",
                        "type": "boolean",
                        "description": "Only return listings that display LocalHarvest's SNAP/EBT-accepted badge (mode=search).",
                        "default": false
                    },
                    "organicOnly": {
                        "title": "Certified Organic only",
                        "type": "boolean",
                        "description": "Only return listings that display LocalHarvest's Certified Organic badge (mode=search).",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "rating",
                            "name"
                        ],
                        "type": "string",
                        "description": "How to order search results after fetching (mode=search). LocalHarvest itself returns results ordered by distance/relevance; 'rating' and 'name' are applied client-side across the fetched batch.",
                        "default": "relevance"
                    },
                    "fetchDetails": {
                        "title": "Fetch full listing profiles",
                        "type": "boolean",
                        "description": "For each search result, also visit its listing profile page to collect phone, website, social links, full description, products/crops, farming practices, associations, and market channel details (CSA share info, market schedule). Slower -- one extra request per result (mode=search).",
                        "default": false
                    },
                    "listingUrls": {
                        "title": "Listing profile URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct LocalHarvest listing URLs to fetch, e.g. https://www.localharvest.org/blue-gate-farm-M11943. Use the 'sourceUrl' field from search results.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "LocalHarvest listing profile URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of listing records to return.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
