USA Address Parser

// Step 1: Get your auth token
const auth = await fetch("https://api.sthan.io/Auth/Token", {
  headers: {
    "profileName": "YOUR_PROFILE_NAME",
    "profilePassword": "YOUR_PROFILE_PASSWORD"
  }
});
const { access_token } = await auth.json();

// Step 2: Make the API call
const address = "1600 pennsylvania ave nw washington dc 20500";
const encoded = encodeURIComponent(address);

const response = await fetch(
  `https://api.sthan.io/v2/address-parser/usa/speculative/${encoded}`, {
  headers: { "Authorization": `Bearer ${access_token}` }
});
const data = await response.json();
console.log(data);

import requests
from urllib.parse import quote

# Step 1: Get your auth token
auth = requests.get(
    "https://api.sthan.io/Auth/Token",
    headers={
        "profileName": "YOUR_PROFILE_NAME",
        "profilePassword": "YOUR_PROFILE_PASSWORD"
    }
)
token = auth.json()["access_token"]

# Step 2: Make the API call
address = "1600 pennsylvania ave nw washington dc 20500"
encoded = quote(address)

response = requests.get(
    f"https://api.sthan.io/v2/address-parser/usa/speculative/{encoded}",
    headers={"Authorization": f"Bearer {token}"}
)
data = response.json()
print(data)

using var client = new HttpClient();

// Step 1: Get your auth token
client.DefaultRequestHeaders.Add("profileName", "YOUR_PROFILE_NAME");
client.DefaultRequestHeaders.Add("profilePassword", "YOUR_PROFILE_PASSWORD");
var authJson = await client.GetStringAsync("https://api.sthan.io/Auth/Token");
var auth = JsonSerializer.Deserialize<JsonElement>(authJson);
var token = auth.GetProperty("access_token").GetString();

// Step 2: Make the API call
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", token);

var address = "1600 pennsylvania ave nw washington dc 20500";
var encoded = Uri.EscapeDataString(address);

var response = await client.GetStringAsync(
    $"https://api.sthan.io/v2/address-parser/usa/speculative/{encoded}");
Console.WriteLine(response);

import java.net.*; import java.net.http.*;

// Step 1: Get your auth token
HttpClient client = HttpClient.newHttpClient();
HttpRequest authReq = HttpRequest.newBuilder()
    .uri(URI.create("https://api.sthan.io/Auth/Token"))
    .header("profileName", "YOUR_PROFILE_NAME")
    .header("profilePassword", "YOUR_PROFILE_PASSWORD")
    .build();
HttpResponse<String> authResp = client.send(authReq,
    HttpResponse.BodyHandlers.ofString());
// Parse access_token from authResp.body()

// Step 2: Make the API call
String address = "1600 pennsylvania ave nw washington dc 20500";
String encoded = URLEncoder.encode(address, "UTF-8");

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.sthan.io/v2/address-parser/usa/speculative/" + encoded))
    .header("Authorization", "Bearer " + token)
    .build();
HttpResponse<String> resp = client.send(request,
    HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

// Step 1: Get your auth token
$ch = curl_init("https://api.sthan.io/Auth/Token");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "profileName: YOUR_PROFILE_NAME",
    "profilePassword: YOUR_PROFILE_PASSWORD"
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$data = json_decode(curl_exec($ch), true);
$token = $data["access_token"];

// Step 2: Make the API call
$address = "1600 pennsylvania ave nw washington dc 20500";
$encoded = urlencode($address);

$ch = curl_init("https://api.sthan.io/v2/address-parser/usa/speculative/" . $encoded);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . $token
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
echo $response;

require 'net/http'
require 'json'
require 'uri'

# Step 1: Get your auth token
uri = URI("https://api.sthan.io/Auth/Token")
req = Net::HTTP::Get.new(uri)
req["profileName"] = "YOUR_PROFILE_NAME"
req["profilePassword"] = "YOUR_PROFILE_PASSWORD"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http|
  http.request(req)
}
token = JSON.parse(resp.body)["access_token"]

# Step 2: Make the API call
address = "1600 pennsylvania ave nw washington dc 20500"
encoded = URI.encode_www_form_component(address)

uri = URI("https://api.sthan.io/v2/address-parser/usa/speculative/#{encoded}")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{token}"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http|
  http.request(req)
}
puts JSON.parse(resp.body)

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

// Step 1: Get your auth token
authReq, _ := http.NewRequest("GET", "https://api.sthan.io/Auth/Token", nil)
authReq.Header.Set("profileName", "YOUR_PROFILE_NAME")
authReq.Header.Set("profilePassword", "YOUR_PROFILE_PASSWORD")
authResp, _ := http.DefaultClient.Do(authReq)
defer authResp.Body.Close()
// Parse access_token from response JSON

// Step 2: Make the API call
address := "1600 pennsylvania ave nw washington dc 20500"
encoded := url.QueryEscape(address)

req, _ := http.NewRequest("GET",
    "https://api.sthan.io/v2/address-parser/usa/speculative/" + encoded, nil)
req.Header.Set("Authorization", "Bearer " + token)

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))