Why Hiding Your Prices Is Killing Your AI Visibility

Someone asks ChatGPT: "What are some good espresso machines under $300?"

ChatGPT lists three options. Each with the machine name, key specs, and an exact price. The Breville Bambino at $249. The De'Longhi Dedica at $229. The Nespresso Vertuo at $199.

Your espresso machine at $249 isn't on the list. Not because it's worse. Not because your reviews are bad. You have a 4.7-star average and customers who've called it their best kitchen purchase ever.

But AI doesn't know your price. Because your Shopify store shows "Add to cart to see price." Your product page shows the price only after a user interaction. To AI, your product has no price. To AI, your product doesn't exist for this query.

Why Price Is the First Thing AI Looks For

When someone asks AI for a product recommendation with a budget, the first filter is always price. Before features. Before reviews. Before brand reputation.

"Best laptop under $1,000" — AI needs prices. "Good running shoes in the $100-150 range" — AI needs prices. "Affordable standing desks for a home office" — AI needs prices.

Budget-qualified queries are some of the most common product questions people ask AI. And they're exactly the queries where invisible pricing eliminates you before the evaluation even starts.

Here's what most store owners don't realize: AI isn't reading your price off the page like a human would. It's parsing structured data. It's looking for Offer schema. It needs price information in a machine-readable format that it can confidently extract, verify, and use in a recommendation.

If your price is buried in JavaScript, requires a cart interaction, or simply isn't there in raw HTML, AI files you under "incomplete data" and picks your competitors instead.

The Four Pricing Problems That Kill AI Visibility

1. "Request a Quote" / "Contact for Pricing"

This is the biggest one. Common in B2B e-commerce, custom product stores, and premium brands that believe hiding prices increases perceived value.

For AI: catastrophic.

When AI encounters "contact for pricing," it has zero useful information to work with. It can't recommend you for any price-qualified query. It can't tell someone what to expect. It might not include you in general recommendations at all, because the lack of pricing data signals "incomplete product information."

The solution isn't necessarily to show exact prices. It's to give AI something. A starting price ("from $299"), a price range ("$200-$500 depending on configuration"), or at minimum a clear statement in your schema about the pricing model.

2. Prices Only Visible After Login

Members-only pricing, wholesale accounts, B2B portals. If your pricing is behind a login wall, AI crawlers literally cannot see it.

AI crawlers don't create accounts. They don't log in. They see what any anonymous visitor would see. If that means they see "Log in for pricing" instead of actual numbers, you're invisible for every price-sensitive query.

Fix: Show a public price — even if it's retail MSRP — for all users. If members get discounts, great. But let AI see a baseline price so it can include you in recommendations.

3. Cart-Only Pricing

Prices that only appear in the cart or checkout flow. More common than you'd think, especially on configurable or custom products.

"Build your own" products, subscription boxes with tiered pricing, custom print orders — all potentially showing no price on the product page itself.

AI crawlers don't go through checkout flows. They read product pages. If the price isn't there, AI doesn't have it.

4. JavaScript-Rendered Prices

Even when prices are technically on the page, many AI crawlers can't execute JavaScript. If your price renders dynamically after page load, it might appear perfectly to human visitors but be completely invisible to crawlers.

This is a sneaky one because from your side everything looks fine. The price is there. Customers see it. But AI sees an empty price field where a number should be.

How to check: View the page source (right-click → View Page Source — NOT Inspect Element). If you can't find your price in the raw HTML, AI probably can't either.

How Offer Schema Fixes This

Offer schema is structured data markup specifically designed to give AI and search engines machine-readable pricing information. Combined with Product schema, it's how you tell AI: "This product exists, costs this much, and is currently in stock."

A complete Product + Offer schema looks like this:

{
  "@type": "Product",
  "name": "Professional Chef's Knife 8-inch",
  "offers": {
    "@type": "Offer",
    "price": "89.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://yourstore.com/products/chefs-knife"
  }
}

This is machine-readable, unambiguous, and exactly what AI is looking for when processing a price-qualified query.

What makes Offer schema powerful:

• price — exact, current price
• priceCurrency — the currency (important for international stores)
• availability — in stock, out of stock, pre-order
• priceValidUntil — when the current price expires (critical for sale pricing)
• url — direct link to the product

Most e-commerce platforms add some Offer schema automatically, but the implementation is often incomplete. Run a Recomaze audit to see exactly what's present and what's missing on your product pages.

Sale Pricing: An Opportunity Most Stores Miss

Sale prices are actually a massive opportunity for AI visibility, and most stores mishandle them.

When you have a product on sale, your schema should reflect that clearly — including when the sale ends:

{
  "@type": "Offer",
  "price": "59.99",
  "priceCurrency": "USD",
  "priceValidUntil": "2026-03-01",
  "highPrice": "89.99",
  "lowPrice": "59.99"
}

Now when someone asks AI "are there any deals on chef's knives right now?" — you have a real shot. AI can identify products with active sale pricing and time-limited offers.

Common mistake: Not updating schema when sales end. AI might continue recommending a "sale price" that's reverted to full price. This creates a trust problem when users click through and find a different price. Stale pricing data actively hurts you.

Price Transparency Without Giving Everything Away

Some businesses have legitimate strategic reasons to avoid fully public pricing. Custom products, enterprise software, high-touch sales processes. The concern is real.

But there's a middle ground that works for both your sales strategy and AI visibility:

Option 1: "Starting from" pricing "Pricing starts from $199" gives AI a floor to work with. You can still qualify leads through a sales process for exact pricing.

Option 2: Price ranges "$200–$800 depending on configuration" is vague enough to protect your margins while giving AI enough to include you in budget-qualified queries.

Option 3: Reference pricing Even if your price is negotiated, you can note MSRP or standard pricing in your schema as a reference point.

Option 4: Tiered pricing tables Public pricing for base plans, "contact for enterprise" for custom tiers. The standard pricing is fully visible and schema-marked. The enterprise tier doesn't need a price but should have a clear description.

The key insight: you don't have to expose every pricing nuance. But you do need to give AI something to work with. Any price signal beats none.

The Stock Availability Connection

Related to pricing, availability information is equally important and equally often missing or stale.

When AI recommends a product and it's out of stock, that's a problem. Users click through, can't buy, and lose trust. Schema availability options:

• InStock — available now
• OutOfStock — not currently available
• PreOrder — available for preorder
• LimitedAvailability — low stock
• BackOrder — out of stock but accepting orders

Keeping this accurate matters. AI that confidently recommends an out-of-stock product based on your stale schema is being misled by your incomplete data — and users blame AI for it, not you. But you lose the sale.

Practical tip: Connect your schema generation to your actual inventory system so availability updates automatically. Manual updates don't scale.

What Your Competitors Are Doing Right

Here's a reality check. Go to ChatGPT and ask for product recommendations in your category with a budget filter.

The brands that get recommended? Open their product pages and view source. You'll almost certainly find:

• Prices clearly in the HTML (not just JavaScript-rendered)
• Complete Offer schema with price, currency, and availability
• Accurate, current pricing that matches what's shown on the page

They're not doing anything sophisticated. They're just making their pricing information accessible to machines.

The brands that don't appear? Price in checkout only. Missing Offer schema. Dynamic pricing with no static fallback.

It really is that simple. Accessible pricing data = AI can recommend you. Hidden pricing = AI moves on.

Your Pricing Transparency Action Plan

Step 1: Audit your current state

Run a Recomaze audit to see if Offer schema is present on your product pages and what fields are complete vs missing.

Then manually check 5 of your top product pages:

• View page source (not Inspect Element)
• Search for "price" in the raw HTML
• Is your price visible in the static HTML?
• Is there Offer schema with a price field?

Step 2: Fix the technical implementation

On Shopify, check your theme's schema settings. Most modern themes include Offer schema but may not include all fields. The Dawn theme and most premium themes generate it automatically — verify it's complete.

On WooCommerce, Rank Math or Schema Pro can generate complete Offer schema automatically from your product data.

Custom platforms need manual Product + Offer schema implementation for all product pages.

Step 3: Handle edge cases

• Variable products (multiple sizes/colors with different prices): Use AggregateOffer with lowPrice and highPrice
• Out-of-stock products: Update availability to OutOfStock
• Sale products: Include sale price with priceValidUntil
• Products with login-only pricing: Add public/MSRP pricing for AI visibility

Step 4: Test

After implementing, run Google's Rich Results Test on your product pages. Verify Offer schema is detected with all fields populated. Then ask ChatGPT price-specific queries for your products. Give it 2–4 weeks for recrawling. Are you appearing now?

The Bottom Line

Every price-qualified query — "under $X," "budget," "affordable," "cheap vs expensive" — is an opportunity for AI to recommend you. Or to skip you.

The only thing standing between you and those recommendations is accessible, accurate pricing data.

You don't need to overhaul your pricing strategy. You don't need to discount. You just need to make your prices visible in a way that AI can read and trust.

One afternoon of technical work. Permanent improvement in AI visibility for every price-sensitive query in your category.

Check your pricing schema now — free Recomaze audit shows exactly whether AI can see your prices and what's missing. Takes 2 minutes.