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

# Retrieve fraud risks

GET https://fraud-api.pixalate.com/api/v3/fraud

Returns the probability of fraud and the associated risk types for a specific IP
address, device ID or user agent.

If you don't send an IP address, device ID or user agent, the API returns your
quota metadata instead. See the `Metadata` schema.


Reference: https://docs.pixalate.com/api-reference/fraud/get-fraud

## Authentication

- `x-api-key` header (required) — Authentication and authorization are achieved by supplying your Pixalate provided API key in the request's header. An API key may be obtained by signing up for an account on the [Pixalate developer website](https://developer.pixalate.com).

## Request

### Query parameters

- `ip` (string, optional) — The IP address to look up. Accepts IPv4 and IPv6 addresses.
- `deviceId` (string, optional) — The hardware identifier of the mobile or CTV device to look up. See the `DeviceId` schema for accepted ID types.
- `userAgent` (string, optional) — The user agent string sent by the browser or device. URL-encode the value.
- `pretty` (boolean, optional, default: false) — Returns pretty JSON if true. Default is false.

## Response

### 200

OK

- `Retrieve Fraud Risks_getFraudV3_Response_200`

## Errors

### 400 Bad Request Error

Bad Request - Invalid parameters in request.

- `any`

### 401 Unauthorized Error

Unauthorized - Invalid API Key.

- `any`

### 403 Forbidden Error

Forbidden - Rate plan expired or quota has been exhausted.

- `any`

### 500 Server Error

Server Error - The API experienced an internal error. Contact support.

- `any`

## Types

### FraudInfo

The result of a lookup for an IP address, device ID or user agent.

- `probability` (double, required) — The probability that the lookup value is associated with fraud or invalid traffic, up to 1.0. 0 means the lookup isn't flagged for fraud by Pixalate's fraud intelligence system. -1 means the value you sent is whitelisted. If you send more than one lookup parameter, this reflects the combined risk of all the values you sent.
- `riskTypes` (list of integer, required, nullable) — The risk type codes associated with the lookup values during the look-back period. Can contain more than one code. null if the probability is 0 or -1, or if no risk type is available for a flagged value. Never an empty array. Each code is a four-digit integer that maps to an IVT type in [Pixalate's IVT Taxonomy 2.0](https://www.pixalate.com/knowledgebase/pixalates-ivt-taxonomy-2.0), which lists every code with its name and definition.

### Metadata

Your account's quota status. Returned when you don't send an IP address, device ID or user agent.

- `used` (integer, optional) — The number of requests you've used in the current quota period.
- `limit` (integer, optional, nullable) — The number of requests available in each quota period. null if your plan is unlimited.
- `available` (integer, optional, nullable) — The number of requests you have left in the current quota period. null if your plan is unlimited.
- `unlimited` (boolean, optional) — true if your plan has no request limit. When true, limit, available and expiry are null.
- `interval` (integer, optional) — The number of time units in each quota period. For example, 30 with a timeUnit of day means a 30-day period.
- `timeUnit` (enum, optional) — The time unit for the quota period.
  - Allowed values: `minute`, `hour`, `day`, `week`, `month`
- `expiry` (datetime, optional, nullable) — When the quota resets to the limit, in *YYYY-MM-DDTHH:MM:SS.SSSZ* format. null if your plan is unlimited.

## Examples

### Flagged, with two risk types

**Response**

```json
{
  "probability": 0.92,
  "riskTypes": [
    2502,
    2201
  ]
}
```

**SDK Code**

```python Flagged, with two risk types
import requests

url = "https://fraud-api.pixalate.com/api/v3/fraud"

querystring = {"deviceId":"FF67345D-BF11-7823-1111-FFED421776FC","ip":"203.0.113.24","userAgent":"Mozilla/5.0 (Linux; Android 13; SM-S911B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"}

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

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

print(response.json())
```

```javascript Flagged, with two risk types
const url = 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36';
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 Flagged, with two risk types
package main

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

func main() {

	url := "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36"

	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 Flagged, with two risk types
require 'uri'
require 'net/http'

url = URI("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")

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 Flagged, with two risk types
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Flagged, with two risk types
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Flagged, with two risk types
using RestSharp;

var client = new RestClient("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Flagged, with two risk types
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")! 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()
```

### Multiple values sent, risk types from both

**Response**

```json
{
  "probability": 0.994,
  "riskTypes": [
    2205,
    2202,
    2207
  ]
}
```

**SDK Code**

```python Multiple values sent, risk types from both
import requests

url = "https://fraud-api.pixalate.com/api/v3/fraud"

querystring = {"deviceId":"FF67345D-BF11-7823-1111-FFED421776FC","ip":"203.0.113.24","userAgent":"Mozilla/5.0 (Linux; Android 13; SM-S911B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"}

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

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

print(response.json())
```

```javascript Multiple values sent, risk types from both
const url = 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36';
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 Multiple values sent, risk types from both
package main

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

func main() {

	url := "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36"

	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 Multiple values sent, risk types from both
require 'uri'
require 'net/http'

url = URI("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")

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 Multiple values sent, risk types from both
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Multiple values sent, risk types from both
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Multiple values sent, risk types from both
using RestSharp;

var client = new RestClient("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Multiple values sent, risk types from both
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")! 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()
```

### Not flagged

**Response**

```json
{
  "probability": 0,
  "riskTypes": null
}
```

**SDK Code**

```python Not flagged
import requests

url = "https://fraud-api.pixalate.com/api/v3/fraud"

querystring = {"deviceId":"FF67345D-BF11-7823-1111-FFED421776FC","ip":"203.0.113.24","userAgent":"Mozilla/5.0 (Linux; Android 13; SM-S911B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"}

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

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

print(response.json())
```

```javascript Not flagged
const url = 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36';
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 Not flagged
package main

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

func main() {

	url := "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36"

	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 Not flagged
require 'uri'
require 'net/http'

url = URI("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")

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 Not flagged
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Not flagged
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Not flagged
using RestSharp;

var client = new RestClient("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Not flagged
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")! 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()
```

### Whitelisted

**Response**

```json
{
  "probability": -1,
  "riskTypes": null
}
```

**SDK Code**

```python Whitelisted
import requests

url = "https://fraud-api.pixalate.com/api/v3/fraud"

querystring = {"deviceId":"FF67345D-BF11-7823-1111-FFED421776FC","ip":"203.0.113.24","userAgent":"Mozilla/5.0 (Linux; Android 13; SM-S911B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"}

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

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

print(response.json())
```

```javascript Whitelisted
const url = 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36';
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 Whitelisted
package main

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

func main() {

	url := "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36"

	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 Whitelisted
require 'uri'
require 'net/http'

url = URI("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")

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 Whitelisted
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Whitelisted
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Whitelisted
using RestSharp;

var client = new RestClient("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Whitelisted
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")! 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()
```

### No lookup parameters sent (quota metadata)

**Response**

```json
{
  "available": 5000,
  "expiry": "2026-11-13T00:00:00.000Z",
  "interval": 30,
  "limit": 10000,
  "timeUnit": "day",
  "unlimited": false,
  "used": 5000
}
```

**SDK Code**

```python No lookup parameters sent (quota metadata)
import requests

url = "https://fraud-api.pixalate.com/api/v3/fraud"

querystring = {"deviceId":"FF67345D-BF11-7823-1111-FFED421776FC","ip":"203.0.113.24","userAgent":"Mozilla/5.0 (Linux; Android 13; SM-S911B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"}

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

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

print(response.json())
```

```javascript No lookup parameters sent (quota metadata)
const url = 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36';
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 No lookup parameters sent (quota metadata)
package main

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

func main() {

	url := "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36"

	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 No lookup parameters sent (quota metadata)
require 'uri'
require 'net/http'

url = URI("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")

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 No lookup parameters sent (quota metadata)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php No lookup parameters sent (quota metadata)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp No lookup parameters sent (quota metadata)
using RestSharp;

var client = new RestClient("https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift No lookup parameters sent (quota metadata)
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://fraud-api.pixalate.com/api/v3/fraud?deviceId=FF67345D-BF11-7823-1111-FFED421776FC&ip=203.0.113.24&userAgent=Mozilla%2F5.0+%28Linux%3B+Android+13%3B+SM-S911B%29+AppleWebKit%2F537.36+%28KHTML%2C+like+Gecko%29+Chrome%2F120.0.0.0+Mobile+Safari%2F537.36")! 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()
```