> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.enigmagenomics.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.enigmagenomics.com/_mcp/server.

# Get product details by product code

GET https://api.enigmagenomics.com/products/{pcode}

The Get Product API retrieves detailed information about products on the Enigma platform associated with the authenticated user. This API enables personalized access, ensuring that users can only view the oriduct details

Reference: https://docs.enigmagenomics.com/enigma-lis-integrations/products/pcode/get-product-details-by-product-code

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /products/{pcode}:
    get:
      operationId: Get product details by product code
      summary: Get product details by product code
      description: >-
        The Get Product API retrieves detailed information about products on the
        Enigma platform associated with the authenticated user. This API enables
        personalized access, ensuring that users can only view the oriduct
        details
      tags:
        - pcode
      parameters:
        - name: pcode
          in: path
          description: '(Required) '
          required: true
          schema:
            type: string
        - name: x-api-key
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/products_{pcode}_Get product details by
                  product code_Response_200
        '404':
          description: Not Found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetProductsPcodeRequestNotFoundError'
servers:
  - url: https://api.enigmagenomics.com
    description: https://api.enigmagenomics.com
components:
  schemas:
    ProductsPcodeGetResponsesContentApplicationJsonSchemaData:
      type: object
      properties: {}
      title: ProductsPcodeGetResponsesContentApplicationJsonSchemaData
    products_{pcode}_Get product details by product code_Response_200:
      type: object
      properties:
        code:
          type: integer
        data:
          $ref: >-
            #/components/schemas/ProductsPcodeGetResponsesContentApplicationJsonSchemaData
        message:
          type: string
      required:
        - code
        - data
        - message
      title: products_{pcode}_Get product details by product code_Response_200
    GetProductsPcodeRequestNotFoundError:
      type: object
      properties:
        code:
          type: integer
        data:
          $ref: >-
            #/components/schemas/ProductsPcodeGetResponsesContentApplicationJsonSchemaData
        message:
          type: string
      required:
        - code
        - data
        - message
      title: GetProductsPcodeRequestNotFoundError
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key

```

## Examples



**Response**

```json
{
  "code": 200,
  "data": {
    "analysis_name": "Short Variants and CNV Analysis",
    "brief_description": "The Whole Exome Sequencing- Solo is intended to identify gene/variant combinations that may aid in the diagnosis of patients with rare genetic disorders using a proband-only approach.",
    "brief_description_ar": "",
    "disease_tested": ">7,000 clinically relevant conditions",
    "field_name": "General",
    "long_description": "The Whole Exome Sequencing- Solo is intended to identify gene/variant combinations that may aid in the diagnosis of patients with rare genetic disorders. Our exome analysis evaluates almost all protein-coding Genes in the human genome (>18,000 Genes in a single assay) and detects single nucleotide variants, small insertions and deletions, and intragenic copy number variants. Artificial intelligence (AI)-powered software weighs clinical and genetic information to identify the variants most relevant to each patient's case. Routine case-level reanalysis is included in the cost of the test and performed every 6-12 months for a minimum of 2 years. \r\n\r\nIn the course of carrying out a rigorous analysis of the exome sequence, this test may occasionally incidentally discover genetic changes that are of medical importance but are not directly relevant to the primary reason for the exome testing. If we identify an incidental finding, we will report it in the primary exome report with an appropriate explanation. Enigma Genomics will not report any incidental findings associated with adult-onset neurodegenerative disorders for which there are no interventions available. In keeping with medical practice best standards, incidental findings are considered to fall within Enigma Genomics' duty to notify policy, and there is no option to opt out, even if the finding happens to fall within one of the ACMG secondary findings Genes.",
    "long_description_ar": "",
    "package_name": "Whole Exome Sequencing - Solo",
    "package_name_ar": "",
    "price_b2c": "2950",
    "price_b2c_usd": "885",
    "product_code": "EGEXOSOL",
    "size": "All Coding Genes",
    "tat": "20-30 business days"
  },
  "message": "Product fetched successfully"
}
```

**SDK Code**

```python products_{pcode}_Get product details by product code_example
import requests

url = "https://api.enigmagenomics.com/products/string"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript products_{pcode}_Get product details by product code_example
const url = 'https://api.enigmagenomics.com/products/string';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go products_{pcode}_Get product details by product code_example
package main

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

func main() {

	url := "https://api.enigmagenomics.com/products/string"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

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

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby products_{pcode}_Get product details by product code_example
require 'uri'
require 'net/http'

url = URI("https://api.enigmagenomics.com/products/string")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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

```java products_{pcode}_Get product details by product code_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.enigmagenomics.com/products/string")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php products_{pcode}_Get product details by product code_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.enigmagenomics.com/products/string', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp products_{pcode}_Get product details by product code_example
using RestSharp;

var client = new RestClient("https://api.enigmagenomics.com/products/string");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift products_{pcode}_Get product details by product code_example
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.enigmagenomics.com/products/string")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```