RealValidito Lookup API Documentation

curl "https://app.realvalidito.com/phonelookup/getcredits/YOUR_API_KEY/YOUR_API_SECRET"

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
var apiKey = 'YOUR_API_KEY';
var apiSecret = 'YOUR_API_SECRET';

$.ajax({
  url: 'https://app.realvalidito.com/phonelookup/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret),
  method: 'GET',
  dataType: 'json',
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$apiKey = 'YOUR_API_KEY';
$apiSecret = 'YOUR_API_SECRET';

$ch = curl_init('https://app.realvalidito.com/phonelookup/getcredits/' . rawurlencode($apiKey) . '/' . rawurlencode($apiSecret));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
const apiKey = 'YOUR_API_KEY';
const apiSecret = 'YOUR_API_SECRET';

async function main() {
  const url = 'https://app.realvalidito.com/phonelookup/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret);
  const response = await fetch(url);
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json
from urllib.parse import quote

import requests

api_key = "YOUR_API_KEY"
api_secret = "YOUR_API_SECRET"

url = f"https://app.realvalidito.com/phonelookup/getcredits/{quote(api_key)}/{quote(api_secret)}"
response = requests.get(url, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"
)

func main() {
	apiKey := "YOUR_API_KEY"
	apiSecret := "YOUR_API_SECRET"
	endpoint := "https://app.realvalidito.com/phonelookup/getcredits/" + url.PathEscape(apiKey) + "/" + url.PathEscape(apiSecret)

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Get(endpoint)
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Text.Json;

var apiKey = "YOUR_API_KEY";
var apiSecret = "YOUR_API_SECRET";

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var url = "https://app.realvalidito.com/phonelookup/getcredits/" + Uri.EscapeDataString(apiKey) + "/" + Uri.EscapeDataString(apiSecret);
var body = await client.GetStringAsync(url);

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl -X POST "https://app.realvalidito.com/phonelookup/validate" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "numbers": ["2015550123", "4165550198"]
  }'

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
$.ajax({
  url: 'https://app.realvalidito.com/phonelookup/validate',
  method: 'POST',
  contentType: 'application/json',
  dataType: 'json',
  data: JSON.stringify({
    api_key: 'YOUR_API_KEY',
    api_secret: 'YOUR_API_SECRET',
    numbers: ['2015550123', '4165550198']
  }),
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$payload = json_encode([
    'api_key'    => 'YOUR_API_KEY',
    'api_secret' => 'YOUR_API_SECRET',
    'numbers' => ['2015550123', '4165550198'],
]);

$ch = curl_init('https://app.realvalidito.com/phonelookup/validate');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
async function main() {
  const response = await fetch('https://app.realvalidito.com/phonelookup/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      api_key: 'YOUR_API_KEY',
      api_secret: 'YOUR_API_SECRET',
      numbers: ['2015550123', '4165550198']
    })
  });
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json

import requests

payload = {
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "numbers": ["2015550123", "4165550198"],
}

response = requests.post("https://app.realvalidito.com/phonelookup/validate", json=payload, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

func main() {
	payload, err := json.Marshal(map[string]any{
		"api_key":    "YOUR_API_KEY",
		"api_secret": "YOUR_API_SECRET",
		"numbers": []string{"2015550123", "4165550198"},
	})
	if err != nil {
		fmt.Println(err)
		return
	}

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Post("https://app.realvalidito.com/phonelookup/validate", "application/json", bytes.NewReader(payload))
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var payload = new
{
    api_key = "YOUR_API_KEY",
    api_secret = "YOUR_API_SECRET",
    numbers = new[] { "2015550123", "4165550198" }
};

var response = await client.PostAsJsonAsync("https://app.realvalidito.com/phonelookup/validate", payload);
var body = await response.Content.ReadAsStringAsync();

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl "https://app.realvalidito.com/dnclookup/getcredits/YOUR_API_KEY/YOUR_API_SECRET"

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
var apiKey = 'YOUR_API_KEY';
var apiSecret = 'YOUR_API_SECRET';

$.ajax({
  url: 'https://app.realvalidito.com/dnclookup/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret),
  method: 'GET',
  dataType: 'json',
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$apiKey = 'YOUR_API_KEY';
$apiSecret = 'YOUR_API_SECRET';

$ch = curl_init('https://app.realvalidito.com/dnclookup/getcredits/' . rawurlencode($apiKey) . '/' . rawurlencode($apiSecret));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
const apiKey = 'YOUR_API_KEY';
const apiSecret = 'YOUR_API_SECRET';

async function main() {
  const url = 'https://app.realvalidito.com/dnclookup/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret);
  const response = await fetch(url);
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json
from urllib.parse import quote

import requests

api_key = "YOUR_API_KEY"
api_secret = "YOUR_API_SECRET"

url = f"https://app.realvalidito.com/dnclookup/getcredits/{quote(api_key)}/{quote(api_secret)}"
response = requests.get(url, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"
)

func main() {
	apiKey := "YOUR_API_KEY"
	apiSecret := "YOUR_API_SECRET"
	endpoint := "https://app.realvalidito.com/dnclookup/getcredits/" + url.PathEscape(apiKey) + "/" + url.PathEscape(apiSecret)

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Get(endpoint)
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Text.Json;

var apiKey = "YOUR_API_KEY";
var apiSecret = "YOUR_API_SECRET";

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var url = "https://app.realvalidito.com/dnclookup/getcredits/" + Uri.EscapeDataString(apiKey) + "/" + Uri.EscapeDataString(apiSecret);
var body = await client.GetStringAsync(url);

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl -X POST "https://app.realvalidito.com/dnclookup/validate" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "numbers": ["2015550123", "2015550124"]
  }'

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
$.ajax({
  url: 'https://app.realvalidito.com/dnclookup/validate',
  method: 'POST',
  contentType: 'application/json',
  dataType: 'json',
  data: JSON.stringify({
    api_key: 'YOUR_API_KEY',
    api_secret: 'YOUR_API_SECRET',
    numbers: ['2015550123', '2015550124']
  }),
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$payload = json_encode([
    'api_key'    => 'YOUR_API_KEY',
    'api_secret' => 'YOUR_API_SECRET',
    'numbers' => ['2015550123', '2015550124'],
]);

$ch = curl_init('https://app.realvalidito.com/dnclookup/validate');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
async function main() {
  const response = await fetch('https://app.realvalidito.com/dnclookup/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      api_key: 'YOUR_API_KEY',
      api_secret: 'YOUR_API_SECRET',
      numbers: ['2015550123', '2015550124']
    })
  });
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json

import requests

payload = {
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "numbers": ["2015550123", "2015550124"],
}

response = requests.post("https://app.realvalidito.com/dnclookup/validate", json=payload, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

func main() {
	payload, err := json.Marshal(map[string]any{
		"api_key":    "YOUR_API_KEY",
		"api_secret": "YOUR_API_SECRET",
		"numbers": []string{"2015550123", "2015550124"},
	})
	if err != nil {
		fmt.Println(err)
		return
	}

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Post("https://app.realvalidito.com/dnclookup/validate", "application/json", bytes.NewReader(payload))
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var payload = new
{
    api_key = "YOUR_API_KEY",
    api_secret = "YOUR_API_SECRET",
    numbers = new[] { "2015550123", "2015550124" }
};

var response = await client.PostAsJsonAsync("https://app.realvalidito.com/dnclookup/validate", payload);
var body = await response.Content.ReadAsStringAsync();

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl "https://app.realvalidito.com/lookups/getcredits/YOUR_API_KEY/YOUR_API_SECRET"

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
var apiKey = 'YOUR_API_KEY';
var apiSecret = 'YOUR_API_SECRET';

$.ajax({
  url: 'https://app.realvalidito.com/lookups/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret),
  method: 'GET',
  dataType: 'json',
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$apiKey = 'YOUR_API_KEY';
$apiSecret = 'YOUR_API_SECRET';

$ch = curl_init('https://app.realvalidito.com/lookups/getcredits/' . rawurlencode($apiKey) . '/' . rawurlencode($apiSecret));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
const apiKey = 'YOUR_API_KEY';
const apiSecret = 'YOUR_API_SECRET';

async function main() {
  const url = 'https://app.realvalidito.com/lookups/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret);
  const response = await fetch(url);
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json
from urllib.parse import quote

import requests

api_key = "YOUR_API_KEY"
api_secret = "YOUR_API_SECRET"

url = f"https://app.realvalidito.com/lookups/getcredits/{quote(api_key)}/{quote(api_secret)}"
response = requests.get(url, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"
)

func main() {
	apiKey := "YOUR_API_KEY"
	apiSecret := "YOUR_API_SECRET"
	endpoint := "https://app.realvalidito.com/lookups/getcredits/" + url.PathEscape(apiKey) + "/" + url.PathEscape(apiSecret)

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Get(endpoint)
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Text.Json;

var apiKey = "YOUR_API_KEY";
var apiSecret = "YOUR_API_SECRET";

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var url = "https://app.realvalidito.com/lookups/getcredits/" + Uri.EscapeDataString(apiKey) + "/" + Uri.EscapeDataString(apiSecret);
var body = await client.GetStringAsync(url);

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl -X POST "https://app.realvalidito.com/lookups/validate" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "numbers": ["2015550123", "4165550198"]
  }'

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
$.ajax({
  url: 'https://app.realvalidito.com/lookups/validate',
  method: 'POST',
  contentType: 'application/json',
  dataType: 'json',
  data: JSON.stringify({
    api_key: 'YOUR_API_KEY',
    api_secret: 'YOUR_API_SECRET',
    numbers: ['2015550123', '4165550198']
  }),
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$payload = json_encode([
    'api_key'    => 'YOUR_API_KEY',
    'api_secret' => 'YOUR_API_SECRET',
    'numbers' => ['2015550123', '4165550198'],
]);

$ch = curl_init('https://app.realvalidito.com/lookups/validate');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
async function main() {
  const response = await fetch('https://app.realvalidito.com/lookups/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      api_key: 'YOUR_API_KEY',
      api_secret: 'YOUR_API_SECRET',
      numbers: ['2015550123', '4165550198']
    })
  });
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json

import requests

payload = {
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "numbers": ["2015550123", "4165550198"],
}

response = requests.post("https://app.realvalidito.com/lookups/validate", json=payload, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

func main() {
	payload, err := json.Marshal(map[string]any{
		"api_key":    "YOUR_API_KEY",
		"api_secret": "YOUR_API_SECRET",
		"numbers": []string{"2015550123", "4165550198"},
	})
	if err != nil {
		fmt.Println(err)
		return
	}

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Post("https://app.realvalidito.com/lookups/validate", "application/json", bytes.NewReader(payload))
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var payload = new
{
    api_key = "YOUR_API_KEY",
    api_secret = "YOUR_API_SECRET",
    numbers = new[] { "2015550123", "4165550198" }
};

var response = await client.PostAsJsonAsync("https://app.realvalidito.com/lookups/validate", payload);
var body = await response.Content.ReadAsStringAsync();

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl "https://app.realvalidito.com/genderlookup/getcredits/YOUR_API_KEY/YOUR_API_SECRET"

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
var apiKey = 'YOUR_API_KEY';
var apiSecret = 'YOUR_API_SECRET';

$.ajax({
  url: 'https://app.realvalidito.com/genderlookup/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret),
  method: 'GET',
  dataType: 'json',
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$apiKey = 'YOUR_API_KEY';
$apiSecret = 'YOUR_API_SECRET';

$ch = curl_init('https://app.realvalidito.com/genderlookup/getcredits/' . rawurlencode($apiKey) . '/' . rawurlencode($apiSecret));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
const apiKey = 'YOUR_API_KEY';
const apiSecret = 'YOUR_API_SECRET';

async function main() {
  const url = 'https://app.realvalidito.com/genderlookup/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret);
  const response = await fetch(url);
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json
from urllib.parse import quote

import requests

api_key = "YOUR_API_KEY"
api_secret = "YOUR_API_SECRET"

url = f"https://app.realvalidito.com/genderlookup/getcredits/{quote(api_key)}/{quote(api_secret)}"
response = requests.get(url, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"
)

func main() {
	apiKey := "YOUR_API_KEY"
	apiSecret := "YOUR_API_SECRET"
	endpoint := "https://app.realvalidito.com/genderlookup/getcredits/" + url.PathEscape(apiKey) + "/" + url.PathEscape(apiSecret)

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Get(endpoint)
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Text.Json;

var apiKey = "YOUR_API_KEY";
var apiSecret = "YOUR_API_SECRET";

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var url = "https://app.realvalidito.com/genderlookup/getcredits/" + Uri.EscapeDataString(apiKey) + "/" + Uri.EscapeDataString(apiSecret);
var body = await client.GetStringAsync(url);

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl -X POST "https://app.realvalidito.com/genderlookup/validate" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "names": ["Maria", "Jordan"]
  }'

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
$.ajax({
  url: 'https://app.realvalidito.com/genderlookup/validate',
  method: 'POST',
  contentType: 'application/json',
  dataType: 'json',
  data: JSON.stringify({
    api_key: 'YOUR_API_KEY',
    api_secret: 'YOUR_API_SECRET',
    names: ['Maria', 'Jordan']
  }),
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$payload = json_encode([
    'api_key'    => 'YOUR_API_KEY',
    'api_secret' => 'YOUR_API_SECRET',
    'names' => ['Maria', 'Jordan'],
]);

$ch = curl_init('https://app.realvalidito.com/genderlookup/validate');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
async function main() {
  const response = await fetch('https://app.realvalidito.com/genderlookup/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      api_key: 'YOUR_API_KEY',
      api_secret: 'YOUR_API_SECRET',
      names: ['Maria', 'Jordan']
    })
  });
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json

import requests

payload = {
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "names": ["Maria", "Jordan"],
}

response = requests.post("https://app.realvalidito.com/genderlookup/validate", json=payload, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

func main() {
	payload, err := json.Marshal(map[string]any{
		"api_key":    "YOUR_API_KEY",
		"api_secret": "YOUR_API_SECRET",
		"names": []string{"Maria", "Jordan"},
	})
	if err != nil {
		fmt.Println(err)
		return
	}

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Post("https://app.realvalidito.com/genderlookup/validate", "application/json", bytes.NewReader(payload))
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var payload = new
{
    api_key = "YOUR_API_KEY",
    api_secret = "YOUR_API_SECRET",
    names = new[] { "Maria", "Jordan" }
};

var response = await client.PostAsJsonAsync("https://app.realvalidito.com/genderlookup/validate", payload);
var body = await response.Content.ReadAsStringAsync();

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl "https://app.realvalidito.com/ziplookup/getcredits/YOUR_API_KEY/YOUR_API_SECRET"

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
var apiKey = 'YOUR_API_KEY';
var apiSecret = 'YOUR_API_SECRET';

$.ajax({
  url: 'https://app.realvalidito.com/ziplookup/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret),
  method: 'GET',
  dataType: 'json',
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$apiKey = 'YOUR_API_KEY';
$apiSecret = 'YOUR_API_SECRET';

$ch = curl_init('https://app.realvalidito.com/ziplookup/getcredits/' . rawurlencode($apiKey) . '/' . rawurlencode($apiSecret));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
const apiKey = 'YOUR_API_KEY';
const apiSecret = 'YOUR_API_SECRET';

async function main() {
  const url = 'https://app.realvalidito.com/ziplookup/getcredits/' + encodeURIComponent(apiKey) + '/' + encodeURIComponent(apiSecret);
  const response = await fetch(url);
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json
from urllib.parse import quote

import requests

api_key = "YOUR_API_KEY"
api_secret = "YOUR_API_SECRET"

url = f"https://app.realvalidito.com/ziplookup/getcredits/{quote(api_key)}/{quote(api_secret)}"
response = requests.get(url, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"
)

func main() {
	apiKey := "YOUR_API_KEY"
	apiSecret := "YOUR_API_SECRET"
	endpoint := "https://app.realvalidito.com/ziplookup/getcredits/" + url.PathEscape(apiKey) + "/" + url.PathEscape(apiSecret)

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Get(endpoint)
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Text.Json;

var apiKey = "YOUR_API_KEY";
var apiSecret = "YOUR_API_SECRET";

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var url = "https://app.realvalidito.com/ziplookup/getcredits/" + Uri.EscapeDataString(apiKey) + "/" + Uri.EscapeDataString(apiSecret);
var body = await client.GetStringAsync(url);

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));

curl -X POST "https://app.realvalidito.com/ziplookup/validate" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "zipcodes": ["10001", "M5V 2T6"]
  }'

// Run this in an internal tool or behind a login only: never put your API secret into a public web page.
$.ajax({
  url: 'https://app.realvalidito.com/ziplookup/validate',
  method: 'POST',
  contentType: 'application/json',
  dataType: 'json',
  data: JSON.stringify({
    api_key: 'YOUR_API_KEY',
    api_secret: 'YOUR_API_SECRET',
    zipcodes: ['10001', 'M5V 2T6']
  }),
  success: function (data) {
    console.log(data);
  },
  error: function (xhr) {
    console.error(xhr.status, xhr.responseText);
  }
});

<?php
$payload = json_encode([
    'api_key'    => 'YOUR_API_KEY',
    'api_secret' => 'YOUR_API_SECRET',
    'zipcodes' => ['10001', 'M5V 2T6'],
]);

$ch = curl_init('https://app.realvalidito.com/ziplookup/validate');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$response = curl_exec($ch);
if ($response === false) {
    die('Request failed: ' . curl_error($ch));
}
curl_close($ch);

echo json_encode(json_decode($response, true), JSON_PRETTY_PRINT);

// Node.js 18+ (built-in fetch)
async function main() {
  const response = await fetch('https://app.realvalidito.com/ziplookup/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      api_key: 'YOUR_API_KEY',
      api_secret: 'YOUR_API_SECRET',
      zipcodes: ['10001', 'M5V 2T6']
    })
  });
  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
}

main().catch(console.error);

import json

import requests

payload = {
    "api_key": "YOUR_API_KEY",
    "api_secret": "YOUR_API_SECRET",
    "zipcodes": ["10001", "M5V 2T6"],
}

response = requests.post("https://app.realvalidito.com/ziplookup/validate", json=payload, timeout=30)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

func main() {
	payload, err := json.Marshal(map[string]any{
		"api_key":    "YOUR_API_KEY",
		"api_secret": "YOUR_API_SECRET",
		"zipcodes": []string{"10001", "M5V 2T6"},
	})
	if err != nil {
		fmt.Println(err)
		return
	}

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Post("https://app.realvalidito.com/ziplookup/validate", "application/json", bytes.NewReader(payload))
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read failed:", err)
		return
	}
	var result map[string]any
	if err := json.Unmarshal(body, &result); err != nil {
		fmt.Println("invalid JSON:", err)
		return
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	fmt.Println(string(pretty))
}

// .NET 6+ console app
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
var payload = new
{
    api_key = "YOUR_API_KEY",
    api_secret = "YOUR_API_SECRET",
    zipcodes = new[] { "10001", "M5V 2T6" }
};

var response = await client.PostAsJsonAsync("https://app.realvalidito.com/ziplookup/validate", payload);
var body = await response.Content.ReadAsStringAsync();

using var doc = JsonDocument.Parse(body);
Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));