Pinch Grocery Prices (Australia)

Search Australian grocery products across Woolworths, Coles, Aldi, and Harris Farm. Returns product name, price, brand, category, unit price, and whether it's on special.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search query (e.g., 'full cream milk', 'chicken breast')"
    },
    "retailer": {
      "type": "string",
      "enum": [
        "Woolworths",
        "Coles",
        "Aldi",
        "Harris Farm"
      ]
    },
    "category": {
      "type": "string",
      "description": "Filter by category"
    },
    "on_special": {
      "type": "boolean",
      "description": "If true, only return products on special"
    },
    "sort": {
      "type": "string",
      "enum": [
        "relevance",
        "price_asc",
        "price_desc",
        "unit_price_asc"
      ],
      "default": "relevance"
    },
    "limit": {
      "type": "number",
      "description": "Number of results (1-50, default 20)"
    }
  },
  "required": [
    "query"
  ]
}

Get detailed information about a specific grocery product by its ID. Product IDs are returned in search results.

{
  "type": "object",
  "properties": {
    "product_id": {
      "type": "string",
      "description": "Product ID from search results"
    }
  },
  "required": [
    "product_id"
  ]
}

Compare prices for the same product across retailers using its barcode. Returns all retailers stocking the product, sorted cheapest first. About 7,800 products have barcode matches.

{
  "type": "object",
  "properties": {
    "barcode": {
      "type": "string",
      "description": "EAN-13 barcode (e.g., '9300675016902')"
    }
  },
  "required": [
    "barcode"
  ]
}

Get historical price data for a product. Shows price changes over time with stats (lowest, highest, average). History depth depends on your tier (30-365 days).

{
  "type": "object",
  "properties": {
    "product_id": {
      "type": "string",
      "description": "Product ID from search results"
    },
    "days": {
      "type": "number",
      "description": "Number of days of history (default: max for your tier)"
    }
  },
  "required": [
    "product_id"
  ]
}

Get current grocery specials and promotions. Filter by retailer or category. Results include savings amounts. Updated weekly. Specials captured before the most recent Wednesday catalogue changeover (Coles/Woolworths) are excluded as unconfirmed; after a changeover the list can be near-empty until the next collection. Individual products still expose such prices via get_product with special_may_have_ended: true.

{
  "type": "object",
  "properties": {
    "retailer": {
      "type": "string",
      "enum": [
        "Woolworths",
        "Coles",
        "Aldi",
        "Harris Farm"
      ]
    },
    "category": {
      "type": "string",
      "description": "Filter by category"
    },
    "limit": {
      "type": "number",
      "description": "Number of results (1-50, default 20)"
    }
  }
}

Find the cheapest option for a product across all Australian grocery retailers. Searches by name and returns results sorted by price ascending.

{
  "type": "object",
  "properties": {
    "product_name": {
      "type": "string",
      "description": "Product to search for (e.g., 'full cream milk 2L')"
    },
    "limit": {
      "type": "number",
      "description": "Number of results (1-50, default 10)"
    }
  },
  "required": [
    "product_name"
  ]
}

ADVANCED / single item. Do NOT use this to build a shopping list: for any list of 2 or more items, call build_basket (one call, server-side). Use decompose_product only to break ONE item into structured search attributes when you intend to override build_basket's pick for that single item. This does not call any API; it is a structured reasoning step. OUTPUT: canonical_query, disqualifiers, and suggested_category for that single item. Fill in every field based on what a typical Australian family would mean by this item. CORE RULE: Unless the user literally specifies a brand, brand_preference MUST be null and the strategy is cheapest-first (unit_price_asc, no retailer filter).

{
  "type": "object",
  "properties": {
    "raw_input": {
      "type": "string",
      "description": "The item exactly as the user wrote it"
    },
    "category_path": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Ontological path from general to specific, e.g. ['meat', 'poultry', 'chicken', 'breast'] or ['pantry', 'cereal', 'wheat biscuits']"
    },
    "canonical_query": {
      "type": "string",
      "description": "The cleaned search term to use with search_products. Strip sizes and brands (unless brand IS the product, like 'Vegemite'). 'chicken breast bulk pack' becomes 'chicken breast fillets'. 'Sanitarium Weet-Bix' becomes 'Weet-Bix'. 'full cream milk 2L' becomes 'full cream milk'."
    },
    "quantity": {
      "type": "object",
      "properties": {
        "size": {
          "type": "string",
          "description": "Expected size, e.g. '1kg', '2L', '6-pack'"
        },
        "intent": {
          "type": "string",
          "description": "Size intent: 'family' (2-3L/1-2kg), 'single serve', 'standard', 'bulk'"
        }
      },
      "description": "Target size. Use to filter results after search. Family intent means prefer larger sizes for better unit price."
    },
    "qualifiers": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Soft preferences that improve a match but don't disqualify if absent. e.g. ['skinless', 'boneless'] for chicken breast, ['Australian'] for sultanas"
    },
    "disqualifiers": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Terms that indicate a WRONG product. Results containing these MUST be excluded. e.g. for 'chicken breast': ['thigh', 'drumstick', 'wing', 'nugget', 'schnitzel', 'crumbed', 'marinated']. For 'Vegemite': ['twist', 'scroll', 'shapes', 'cheesy bite']. For 'strawberries': ['yoghurt', 'jam', 'ice cream', 'flavoured']. For 'milk': ['flavoured', 'chocolate', 'coffee', 'almond', 'oat', 'soy', 'coconut']."
    },
    "barcode_eligible": {
      "type": "boolean",
      "description": "true for branded packaged goods (Weet-Bix, Vegemite, cheese slices, chips). false for fresh produce, meat, and store-brand generics. When true AND a result has a barcode, call compare_prices to check if another retailer has it cheaper."
    },
    "suggested_category": {
      "type": "string",
      "description": "The grocery store category to filter search results. Use this to prevent wrong-category contamination. e.g. 'Pantry' for rice crackers (prevents dairy lunch packs), 'Fruit & Vegetables' for fresh produce, 'Meat & Seafood' for meat, 'Dairy, Eggs & Fridge' for dairy, 'Frozen' for frozen items. Only set when the item clearly belongs to one category and cross-category results would be noise."
    },
    "brand_preference": {
      "type": "string",
      "description": "ONLY set this if the user LITERALLY named a brand (e.g. 'Weet-Bix', 'Vegemite'). If the user wrote a generic item like 'milk', 'chicken breast', 'eggs', 'bread', this MUST be null. When null, Pinch finds the cheapest option regardless of brand."
    }
  },
  "required": [
    "raw_input",
    "category_path",
    "canonical_query",
    "quantity",
    "qualifiers",
    "disqualifiers",
    "barcode_eligible"
  ]
}

ADVANCED / manual selection. Do NOT use this to build a shopping list: for any list of 2 or more items, call build_basket (one call, server-side, cheapest pick per item). Use batch_search only when you need the RAW candidate products for items you intend to select MANUALLY (for example, to override build_basket's pick on one item). It searches multiple items in parallel and returns raw candidate products per query (up to candidates_per_retailer per retailer) with NO filtering or scoring applied. WORKFLOW: 1. Call batch_search with your shopping list items 2. Review the candidates for each item. For each query, pick the single best product_id per retailer that actually matches what the user wants (correct product type, reasonable size, not a different product). If none of the candidates are a good match for a query, call batch_search again with a refined query (e.g., more specific terms, different wording) 3. Once you have confirmed product_id selections for all items, call save_basket with your picks TIPS: - Set product_type to help narrow results to the right category (e.g., fresh_produce for herbs and vegetables) - Each candidate includes a product_categories field (JSON array of retailer category labels like 'Yoghurt', 'Herbs & Spices', 'Sausages'). Use this to distinguish the actual product type when names are ambiguous (e.g., 'oregano' the herb vs 'oregano sausages') - Prefer products where the name clearly matches the query intent - For staples (milk, eggs, bread), the cheapest option is usually the store brand - If results look wrong (e.g., searching 'rosemary' returns snacks instead of herbs), retry with a more specific query like 'fresh rosemary' - Each item includes a 'cheapest' hint with one entry per retailer. This is the cheapest candidate whose product_categories match the inferred subcategory for the query, NOT necessarily the lowest unit_price overall: a clearly off-category cheaper item (e.g., a snack bar under 'peanut butter') is deliberately excluded. When no category signal is available it falls back to the raw lowest unit_price. Treat the hint as advisory and confirm against the full candidate list and the user's intended format. AMBIGUITY: When candidates for a query span clearly different product formats (e.g., microwave rice pouches vs dry rice bags, single-serve vs family/bulk sizes, flavoured vs plain variants, fresh vs frozen), ASK the user which format they prefer before selecting a product. Compare the size field across candidates to detect this: a spread from 125g to 5kg signals format ambiguity. Do not silently pick the cheapest option when it may be the wrong format (e.g., a 250g microwave pouch when the user likely wants a 1kg bag).

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "description": "Item name as on a shopping list (e.g., 'chicken breast 1kg', 'fresh rosemary', 'sea salt')"
          },
          "product_type": {
            "type": "string",
            "enum": [
              "fresh_produce",
              "meat",
              "dairy",
              "pantry",
              "frozen",
              "drinks",
              "bakery",
              "deli"
            ],
            "description": "Category hint. Set fresh_produce for fruits/vegetables/herbs, meat for raw proteins, dairy for milk/cheese/eggs/yoghurt, pantry for canned/dried/shelf-stable goods."
          },
          "category": {
            "type": "string",
            "description": "Explicit category filter (e.g., 'Fruit & Vegetables'). Overrides product_type."
          }
        },
        "required": [
          "query"
        ]
      },
      "description": "List of grocery items to search (1-20 items)."
    },
    "retailers": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "Woolworths",
          "Coles",
          "Aldi",
          "Harris Farm"
        ]
      },
      "description": "Filter to these retailers only. If omitted, all 4 are searched."
    },
    "candidates_per_retailer": {
      "type": "number",
      "description": "Number of candidate products to return per retailer per item (1-30, default 10). Use more candidates if you expect ambiguous results."
    }
  },
  "required": [
    "items"
  ]
}

ADVANCED / manual commit. Do NOT use this to build a basket from a shopping list: for any list of 2 or more items, call build_basket (it searches, picks the cheapest, totals, and returns a share_url in one call). Use save_basket only to commit a basket from product_ids you have ALREADY chosen yourself (for example, after overriding build_basket's pick on an item). It computes totals and returns a shareable basket URL. For each item, provide the query string and one product_id per retailer (the best match you found in batch_search results). You do NOT need a pick for every retailer; omit a retailer if no good match was found. IMPORTANT: Only call this after you have reviewed batch_search results and confirmed your picks. Do not pass product_ids blindly from search results.

{
  "type": "object",
  "properties": {
    "selections": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "description": "Original search query (for display in basket)"
          },
          "picks": {
            "type": "object",
            "description": "Best product_id per retailer. Keys are retailer names (Woolworths, Coles, Aldi, Harris Farm). Values are product_id strings.",
            "additionalProperties": {
              "type": "string"
            }
          }
        },
        "required": [
          "query",
          "picks"
        ]
      },
      "description": "List of confirmed product selections, one entry per shopping list item."
    }
  },
  "required": [
    "selections"
  ]
}

MANDATORY for shopping lists. When the user gives you 2 or more grocery items, call this tool ONCE with the full list. Do NOT call decompose_product, search_products, or batch_search per item: this tool searches every item in parallel with built-in query analysis (category routing, brand aliases, subcategory boost) and returns a basket with per-item cheapest pick, per-retailer options, basket total, retailer totals, and a shareable share_url. If the user named the stores they shop at, pass them in 'retailers'; otherwise omit it to search all four. VALIDATION (mandatory before rendering): The search engine uses keyword matching, so wrong products leak through. Items flagged with a 'review' field on their cheapest pick are LIKELY WRONG and need your attention first. Then scan ALL picks (flagged or not) and check: (1) Is the product actually what was asked for? (e.g. 'frozen chips' is NOT 'frozen blueberries', 'sweet potato' is NOT 'potato', 'chicken fingers crumbed' is NOT 'chicken breast') (2) Is the size/form correct? (e.g. 400g pack is not a valid match for '2kg') (3) Is the selected option the cheapest CORRECT product, not just the cheapest product? If a pick is wrong: pick the correct product from by_retailer options for that item, or mark as '(check in store)'. Recalculate basket_total from your corrected picks. OUTPUT FORMAT: Line 1: '**Cheapest basket: $X.XX**' (use corrected basket_total). Then ONE markdown table with columns: Item | Product | Store | Price | Size. Then one line: 'View and share this basket: <share_url>'. Use '(check in store)' in the Product cell for items in items_missing or where no correct product exists. No preamble, no per-item narration, no follow-up offers.

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Shopping list items exactly as the user wrote them, e.g. ['4 bananas', 'whole chicken', '12 free range eggs', 'full cream milk 2L', 'spaghetti', 'sliced white bread']. Include any size/quantity in the string ('2L', '1kg', '12 pack') so the cheapest CORRECT size is chosen."
    },
    "retailers": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "Woolworths",
          "Coles",
          "Aldi",
          "Harris Farm"
        ]
      },
      "description": "Only return results from these stores. Omit to search all four."
    }
  },
  "required": [
    "items"
  ]
}