# Product Lookup: Request

> Request parameters and a cURL example for the Easyparser PRODUCT_LOOKUP operation: identifier_type, identifier and the common fields.

Source: https://docs.easyparser.com/real-time-integration/product-lookup/request

Send a GET request with `operation=PRODUCT_LOOKUP` to the Real-Time API. You identify the product with `identifier_type` and `identifier`; an ASIN returns its barcodes, and a barcode returns the matching ASINs.

## Endpoint

```http
GET https://realtime.easyparser.com/v1/request
```

## Required parameters

`api_key`, `platform`, `operation` and `domain` are common to every Real-Time request. See [Common Request Fields](/real-time-integration/common-required-request-fields).

| Parameter | Type | Required | Description |
|---|---|---|---|
| `api_key` | string | Yes | Your API key, sent as a query parameter. Find it at [Account > Plan](https://app.easyparser.com/account/plan). |
| `platform` | string | Yes | Target platform. Allowed: `AMZ` (Amazon). |
| `operation` | string | Yes | Operation code in upper case. Allowed: `PRODUCT_LOOKUP`. |
| `domain` | string | Yes | Amazon marketplace, written with a leading dot, for example `.com`. See [Supported Marketplaces](/essentials/supported-marketplaces). |
| `identifier_type` | string | Yes | Type of the code in `identifier`. Must match the code. Allowed: `ASIN`, `EAN`, `GTIN`, `ISBN`, `JAN`, `MINSAN`, `UPC`. |
| `identifier` | string | Yes | The product code value. Send it as a string and keep leading zeros. Max 18 characters. |

### Identifier types

| `identifier_type` | Identifier | Format |
|---|---|---|
| `ASIN` | Amazon Standard Identification Number | 10 alphanumeric characters, upper case |
| `UPC` | Universal Product Code | 12 digits |
| `EAN` | European Article Number | 13 digits |
| `GTIN` | Global Trade Item Number | Digits |
| `ISBN` | International Standard Book Number | 10 or 13 characters |
| `JAN` | Japanese Article Number | Digits |
| `MINSAN` | Italian Ministry of Health product code | Digits |

Barcode types take digits only. Send the code exactly as printed, including leading zeros, and set `identifier_type` to the matching type.

## Optional parameters

This operation has no operation-specific optional parameters. Only the shared `output` parameter applies (Default: `json`. Allowed: `json`). `PRODUCT_LOOKUP` does not support `language`, `currency`, `associate_id`, `parameters`, `cookie` or the address parameters (`address_id`, `zip_code`, `city`, `district`, `country_code`). See [Common Request Fields](/real-time-integration/common-required-request-fields#shared-optional-parameters).

## Credit cost

Each successful request costs 1 credit. See [Credit Consumption](/essentials/credit-consumption).

## Example request

**cURL**

```bash
curl --get "https://realtime.easyparser.com/v1/request" \
  --data-urlencode "api_key=YOUR_API_KEY" \
  --data-urlencode "platform=AMZ" \
  --data-urlencode "operation=PRODUCT_LOOKUP" \
  --data-urlencode "domain=.com" \
  --data-urlencode "identifier_type=ASIN" \
  --data-urlencode "identifier=B0CJB6V2L5"
```

**Python**

```python
import requests

params = {
    "api_key": "YOUR_API_KEY",
    "platform": "AMZ",
    "operation": "PRODUCT_LOOKUP",
    "domain": ".com",
    "identifier_type": "ASIN",
    "identifier": "B0CJB6V2L5",
}

response = requests.get("https://realtime.easyparser.com/v1/request", params=params)
print(response.json())
```

**Node.js**

```javascript
const params = new URLSearchParams({
  api_key: "YOUR_API_KEY",
  platform: "AMZ",
  operation: "PRODUCT_LOOKUP",
  domain: ".com",
  identifier_type: "ASIN",
  identifier: "B0CJB6V2L5",
});

const response = await fetch(`https://realtime.easyparser.com/v1/request?${params}`);
const data = await response.json();
console.log(data);
```

**HTTP**

```http
GET /v1/request?api_key=YOUR_API_KEY&platform=AMZ&operation=PRODUCT_LOOKUP&domain=.com&identifier_type=ASIN&identifier=B0CJB6V2L5 HTTP/1.1
Host: realtime.easyparser.com
```

**PHP**

```php
<?php
$params = [
    'api_key' => 'YOUR_API_KEY',
    'platform' => 'AMZ',
    'operation' => 'PRODUCT_LOOKUP',
    'domain' => '.com',
    'identifier_type' => 'ASIN',
    'identifier' => 'B0CJB6V2L5',
];

$url = 'https://realtime.easyparser.com/v1/request?' . http_build_query($params);
$response = file_get_contents($url);
$data = json_decode($response, true);
print_r($data);
```

**Go**

```go
package main

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

func main() {
	params := url.Values{}
	params.Add("api_key", "YOUR_API_KEY")
	params.Add("platform", "AMZ")
	params.Add("operation", "PRODUCT_LOOKUP")
	params.Add("domain", ".com")
	params.Add("identifier_type", "ASIN")
	params.Add("identifier", "B0CJB6V2L5")

	resp, err := http.Get("https://realtime.easyparser.com/v1/request?" + params.Encode())
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}
```

**C#**

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;

var parameters = new Dictionary<string, string>
{
    ["api_key"] = "YOUR_API_KEY",
    ["platform"] = "AMZ",
    ["operation"] = "PRODUCT_LOOKUP",
    ["domain"] = ".com",
    ["identifier_type"] = "ASIN",
    ["identifier"] = "B0CJB6V2L5",
};

var query = string.Join("&", parameters.Select(p =>
    $"{Uri.EscapeDataString(p.Key)}={Uri.EscapeDataString(p.Value)}"));

using var client = new HttpClient();
var response = await client.GetStringAsync($"https://realtime.easyparser.com/v1/request?{query}");
Console.WriteLine(response);
```

**Java**

```java
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class EasyparserRequest {
    public static void main(String[] args) throws Exception {
        Map<String, String> params = new LinkedHashMap<>();
        params.put("api_key", "YOUR_API_KEY");
        params.put("platform", "AMZ");
        params.put("operation", "PRODUCT_LOOKUP");
        params.put("domain", ".com");
        params.put("identifier_type", "ASIN");
        params.put("identifier", "B0CJB6V2L5");

        String query = params.entrySet().stream()
            .map(e -> URLEncoder.encode(e.getKey(), StandardCharsets.UTF_8) + "="
                + URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8))
            .collect(Collectors.joining("&"));

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://realtime.easyparser.com/v1/request?" + query))
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}
```

To look up a barcode instead, change the two identifier parameters, for example `identifier_type=UPC&identifier=724382975021`.

## Notes

- If `identifier_type` does not match the code (for example a 12-digit UPC sent as `EAN`), the request returns no results.
- One identifier can match several Amazon listings. Read `result.search_result.total_product_count` and iterate over `products[]`. See [Response](/real-time-integration/product-lookup/response).
- For keyword search, use the [Search](/real-time-integration/search/request) operation (`SEARCH`).
- In the Bulk API, send the codes as an `identifiers` array with one `identifier_type` per group. See [Bulk Service Request](/bulk-integration/bulk-service-request).