> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hasdata.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Walmart Search Scraper API

The Walmart Search Scraper API allows users to get search results from Walmart based on the specified query, category and storefront. This API enables searching for products on Walmart.

<Info>
  HasData is an independent service and is not affiliated with, endorsed by, or sponsored by Walmart. Walmart is a trademark of its respective owner. This API works with publicly available data only.
</Info>

## Get Your API Key

Sign in at [hasdata.com](https://app.hasdata.com/sign-in), go to your account settings, and copy your API key.
All requests must include your key in the `x-api-key` header.

## Request Cost and API Credits

Each request to the Walmart Search Scraper API consumes **API Credits** from your account balance.

* **Cost per request:** 10 API Credits
* Credits are deducted only for successful requests.
* Your total available credits depend on your active plan.

<Tip>You can use your credits across all HasData APIs. The same credit balance is shared platform-wide.</Tip>
<Warning>**Unused credits do not roll over.** Any remaining credits expire at the end of the current billing period.</Warning>

To monitor your credit usage and remaining balance, sign in to your account dashboard at [app.hasdata.com](https://app.hasdata.com/sign-in).

## Make Your First Request

<CodeGroup>
  ```bash cURL theme={null}
  curl --request GET -G \
    --url 'https://api.hasdata.com/scrape/walmart/search' \
    --data-urlencode 'q=coffee' \
    --data-urlencode 'language=en' \
    --data-urlencode 'sort=bestMatch' \
    --data-urlencode 'deliveryType=shipping' \
    --data-urlencode 'facet=brand:Great Value
  retailer_type:Walmart' \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <your-api-key>'
  ```

  ```javascript Node.js theme={null}
  const axios = require('axios').default;

  const options = {
    method: 'GET',
    url: 'https://api.hasdata.com/scrape/walmart/search',
    params: {
      q: 'coffee',
      language: 'en',
      sort: 'bestMatch',
      deliveryType: 'shipping',
      facet: 'brand:Great Value\nretailer_type:Walmart'
    },
    headers: {'Content-Type': 'application/json', 'x-api-key': '<your-api-key>'}
  };

  try {
    const { data } = await axios.request(options);
    console.log(data);
  } catch (error) {
    console.error(error);
  }
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.hasdata.com/scrape/walmart/search"

  querystring = {"q":"coffee","language":"en","sort":"bestMatch","deliveryType":"shipping","facet":"brand:Great Value\nretailer_type:Walmart"}

  headers = {
      "Content-Type": "application/json",
      "x-api-key": "<your-api-key>"
  }

  response = requests.get(url, headers=headers, params=querystring)

  print(response.json())
  ```

  ```php PHP theme={null}
  <?php

  $params = [
      "q" => "coffee",
      "language" => "en",
      "sort" => "bestMatch",
      "deliveryType" => "shipping",
      "facet" => "brand:Great Value
  retailer_type:Walmart",
  ];

  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.hasdata.com/scrape/walmart/search?" . http_build_query($params),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "Content-Type: application/json",
      "x-api-key: <your-api-key>",
    ],
  ]);

  $response = curl_exec($curl);
  curl_close($curl);

  echo $response;
  ```

  ```java Java theme={null}
  OkHttpClient client = new OkHttpClient();

  HttpUrl url = HttpUrl.parse("https://api.hasdata.com/scrape/walmart/search")
    .newBuilder()
    .addQueryParameter("q", "coffee")
    .addQueryParameter("language", "en")
    .addQueryParameter("sort", "bestMatch")
    .addQueryParameter("deliveryType", "shipping")
    .addQueryParameter("facet", "brand:Great Value
  retailer_type:Walmart")
    .build();

  Request request = new Request.Builder()
    .url(url)
    .get()
    .addHeader("Content-Type", "application/json")
    .addHeader("x-api-key", "<your-api-key>")
    .build();

  Response response = client.newCall(request).execute();
  ```

  ```csharp C# theme={null}
  using System.Net.Http;
  using System.Web;

  var client = new HttpClient();

  var query = HttpUtility.ParseQueryString(string.Empty);
  query["q"] = "coffee";
  query["language"] = "en";
  query["sort"] = "bestMatch";
  query["deliveryType"] = "shipping";
  query["facet"] = "brand:Great Value
  retailer_type:Walmart";

  var url = $"https://api.hasdata.com/scrape/walmart/search?{query}";

  var request = new HttpRequestMessage(new HttpMethod("GET"), url);
  request.Headers.Add("x-api-key", "<your-api-key>");

  using var response = await client.SendAsync(request);
  response.EnsureSuccessStatusCode();
  var content = await response.Content.ReadAsStringAsync();
  Console.WriteLine(content);
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'uri'

  uri = URI("https://api.hasdata.com/scrape/walmart/search")
  params = {
    "q" => "coffee",
    "language" => "en",
    "sort" => "bestMatch",
    "deliveryType" => "shipping",
    "facet" => "brand:Great Value
  retailer_type:Walmart",
  }
  uri.query = URI.encode_www_form(params)

  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Get.new(uri)
  request["Content-Type"] = 'application/json'
  request["x-api-key"] = '<your-api-key>'

  response = http.request(request)
  puts response.read_body
  ```

  ```rust Rust theme={null}
  use reqwest::blocking::Client;

  fn main() -> Result<(), Box<dyn std::error::Error>> {
      let client = Client::new();
      let res = client
          .get("https://api.hasdata.com/scrape/walmart/search")
          .query(&[("q", "coffee")])
          .query(&[("language", "en")])
          .query(&[("sort", "bestMatch")])
          .query(&[("deliveryType", "shipping")])
          .query(&[("facet", "brand:Great Value
  retailer_type:Walmart")])
          .header("Content-Type", "application/json")
          .header("x-api-key", "<your-api-key>")
          .send()?
          .text()?;
      println!("{}", res);
      Ok(())
  }
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"io"
  	"net/http"
  	"net/url"
  )

  func main() {
  	params := url.Values{}
  	params.Set("q", "coffee")
  	params.Set("language", "en")
  	params.Set("sort", "bestMatch")
  	params.Set("deliveryType", "shipping")
  	params.Set("facet", "brand:Great Value
  retailer_type:Walmart")

  	u := "https://api.hasdata.com/scrape/walmart/search?" + params.Encode()

  	req, _ := http.NewRequest("GET", u, nil)
  	req.Header.Add("Content-Type", "application/json")
  	req.Header.Add("x-api-key", "<your-api-key>")

  	res, _ := http.DefaultClient.Do(req)
  	defer res.Body.Close()

  	body, _ := io.ReadAll(res.Body)
  	fmt.Println(string(body))
  }
  ```
</CodeGroup>

## API Parameters

| Parameter | Default Value | Required | Description | |
| - | - | - | - | - |
| `q` | coffee | No | The search term for which to get the search results. It can be omitted only when `catId` is provided, to browse a whole category instead of searching. | |
| `catId` | - | No | Walmart category id, taken from a category URL (for example `976759_1086446_1229651`). Combine it with `q` to search inside a category, or send it alone to browse the whole category. Required unless `q` is provided. | |
| `domain` | - | No | Walmart storefront to search. Each storefront has its own catalog, prices and currency. Default is `walmart.com`. | |
| `language` | en | No | Language of the results. Availability depends on the storefront - `walmart.com` serves `en` and `es`, `walmart.ca` serves `en` and `fr`. A language the storefront does not support falls back to its default. | |
| `sort` | bestMatch | No | The sorting option for the search results. | |
| `url` | - | No | A full Walmart search or category URL to scrape as is. When provided, it overrides `q`, `catId` and the other search parameters, and the storefront is taken from the URL itself. | |
| `page` | - | No | Page number for pagination (e.g., `1` for the first page, `2` for the second page, etc.). Walmart stops serving results after roughly page 10, returning an empty page beyond that. | |
| `minPrice` | - | No | Lower bound of the price range, in the storefront currency. | |
| `maxPrice` | - | No | Upper bound of the price range, in the storefront currency. | |
| `deliveryType` | shipping | No | Keep only the products available with the selected fulfillment method. Default is `shipping`. Note that `pickup` is answered against one Walmart store, so an item in stock nationally can still be unavailable for `pickup` nearby - the response then reports that nothing matched the filters rather than that the query had no results. | |
| `facet` | brand:Great Value | | | |
| retailer\_type:Walmart | No | Walmart filter in the `name:value` form, for example `brand:Great Value`. Every value available for a query is listed in the facets block of the response, each one carrying the exact string to send back here, so a first unfiltered request tells you what can be filtered on. To combine filters, put each one on its own line. The double-pipe form Walmart's own urls use \`brand:Great Value | | retailer\_type:Walmart\` is also accepted. |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.