Complete Guide to Address Verification APIs in 2025

Get authentication token using requests library:

import requests
import os

def get_auth_token(profile_name, profile_password):
    """
    Obtain authentication token from Sthan.io API

    Args:
        profile_name (str): Your profile name
        profile_password (str): Your profile password

    Returns:
        str: Authentication token
    """
    url = 'https://api.sthan.io/auth/token'
    headers = {
        'profileName': profile_name,
        'profilePassword': profile_password
    }

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

    data = response.json()
    return data['Result']['access_token']

# Example usage
profile_name = os.getenv('STHAN_PROFILE_NAME', 'your-profile-name')
profile_password = os.getenv('STHAN_PROFILE_PASSWORD', 'your-profile-password')

token = get_auth_token(profile_name, profile_password)
print(f'Authentication token: {token}')

# Store token as environment variable for later use
os.environ['STHAN_AUTH_TOKEN'] = token

Get authentication token using HttpClient:

using System;
using System.Net.Http;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;

public class SthanAuthService
{
    private readonly HttpClient _httpClient;
    private const string AuthUrl = "https://api.sthan.io/auth/token";

    public SthanAuthService()
    {
        _httpClient = new HttpClient();
    }

    public async Task<string> GetAuthTokenAsync(string profileName, string profilePassword)
    {
        var request = new HttpRequestMessage(HttpMethod.Get, AuthUrl);
        request.Headers.Add("profileName", profileName);
        request.Headers.Add("profilePassword", profilePassword);

        var response = await _httpClient.SendAsync(request);
        response.EnsureSuccessStatusCode();

        var content = await response.Content.ReadAsStringAsync();
        var apiResponse = JsonSerializer.Deserialize<AuthApiResponse>(content);

        return apiResponse.Result.AccessToken;
    }
}

public class AuthApiResponse
{
    public string Id { get; set; }
    public AuthResult Result { get; set; }
    public int StatusCode { get; set; }
    public bool IsError { get; set; }
    public string[] Errors { get; set; }
}

public class AuthResult
{
    [JsonPropertyName("access_token")]
    public string AccessToken { get; set; }

    [JsonPropertyName("expiration")]
    public DateTime Expiration { get; set; }
}

// Example usage
var authService = new SthanAuthService();
var token = await authService.GetAuthTokenAsync("your-profile-name", "your-profile-password");
Console.WriteLine($"Authentication token: {token}");

// Store token for later use (e.g., in configuration or cache)

Get authentication token using Spring RestTemplate:

import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.JsonNode;

public class SthanAuthService {
    private final RestTemplate restTemplate;
    private static final String AUTH_URL = "https://api.sthan.io/auth/token";

    public SthanAuthService() {
        this.restTemplate = new RestTemplate();
    }

    public String getAuthToken(String profileName, String profilePassword) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("profileName", profileName);
        headers.set("profilePassword", profilePassword);

        HttpEntity<Void> request = new HttpEntity<>(headers);

        ResponseEntity<JsonNode> response =
            restTemplate.exchange(AUTH_URL, HttpMethod.GET, request, JsonNode.class);

        if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
            JsonNode resultNode = response.getBody().get("Result");
            return resultNode.get("access_token").asText();
        }

        throw new RuntimeException("Authentication failed");
    }
}

// Example usage
SthanAuthService authService = new SthanAuthService();
String token = authService.getAuthToken("your-profile-name", "your-profile-password");
System.out.println("Authentication token: " + token);

// Store token in configuration or cache for reuse

Get authentication token using Laravel HTTP client:

<?php

namespace App\Services;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Cache;

class SthanAuthService
{
    private const AUTH_URL = 'https://api.sthan.io/auth/token';

    public function getAuthToken(string $profileName, string $profilePassword): string
    {
        $response = Http::withHeaders([
            'profileName' => $profileName,
            'profilePassword' => $profilePassword
        ])->get(self::AUTH_URL);

        if ($response->successful()) {
            $token = $response->json()['Result']['access_token'];

            // Cache token for 15 minutes (token expiration time)
            Cache::put('sthan_auth_token', $token, now()->addMinutes(15));

            return $token;
        }

        throw new \Exception('Authentication failed: ' . $response->status());
    }

    public function getCachedToken(): ?string
    {
        return Cache::get('sthan_auth_token');
    }
}

// Example usage
$authService = new SthanAuthService();
$token = $authService->getAuthToken(
    config('services.sthan.profile_name'),
    config('services.sthan.profile_password')
);

echo "Authentication token: {$token}\n";

Ideal for data processing, Django, Flask, or FastAPI applications:

import requests
import json
from urllib.parse import quote

def verify_address(token, address_string):
    """
    Verify an address using Sthan.io API

    Args:
        token (str): Authentication token from Step 1
        address_string (str): Full address as a single string

    Returns:
        dict: Verification result
    """
    # URL encode the address
    encoded_address = quote(address_string)
    url = f'https://api.sthan.io/AddressVerification/Usa/Single/{encoded_address}'

    headers = {
        'Authorization': f'Bearer {token}'
    }

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

    return response.json()

# Get token from Step 1
token = get_auth_token('your-profile-name', 'your-profile-password')

# Example usage - pass address as a single string
result = verify_address(token, '1199 west shaw avenue fresno california')
print(json.dumps(result, indent=2))

# The API returns:
# {
#   "Result": {
#     "fullAddress": "1199 W Shaw Ave, Fresno, CA 93711",
#     "addressLine1": "1199 W Shaw Ave",
#     "city": "Fresno",
#     "stateCode": "CA",
#     "zipCode": "93711",
#     ...
#   }
# }

# Batch processing example
addresses = [
    '6000 j street sacrmento ca',
    '3808 avenue faradiya davis ca',
    '543 sanders road cross'
]

verified_addresses = [verify_address(token, addr) for addr in addresses]

For ASP.NET, Blazor, or .NET Core applications:

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;
using System.Web;

public class AddressVerificationService
{
    private readonly HttpClient _httpClient;
    private const string ApiBaseUrl = "https://api.sthan.io/AddressVerification/Usa/Single/";

    public AddressVerificationService(string authToken)
    {
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", authToken);
    }

    public async Task<AddressVerificationResult> VerifyAddressAsync(string addressString)
    {
        // URL encode the address
        var encodedAddress = HttpUtility.UrlEncode(addressString);
        var url = $"{ApiBaseUrl}{encodedAddress}";

        var response = await _httpClient.GetAsync(url);
        response.EnsureSuccessStatusCode();

        var responseJson = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<AddressVerificationResult>(responseJson);
    }
}

// Response model classes
public class AddressVerificationResult
{
    public string Id { get; set; }
    public AddressResult Result { get; set; }
    public int StatusCode { get; set; }
    public bool IsError { get; set; }
}

public class AddressResult
{
    public string InputAddress { get; set; }
    public string FullAddress { get; set; }
    public string AddressLine1 { get; set; }
    public string City { get; set; }
    public string StateCode { get; set; }
    public string ZipCode { get; set; }
    public string Zip4 { get; set; }
}

// Get auth token from Step 1
var authService = new SthanAuthService();
var token = await authService.GetAuthTokenAsync("your-profile-name", "your-profile-password");

// Use token for address verification - pass address as single string
var service = new AddressVerificationService(token);
var result = await service.VerifyAddressAsync("3808 avenue faradiya davis ca");

Console.WriteLine($"Input: {result.Result.InputAddress}");
Console.WriteLine($"Verified: {result.Result.FullAddress}");

For enterprise Java applications:

import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriUtils;
import java.nio.charset.StandardCharsets;

public class AddressVerificationService {
    private final RestTemplate restTemplate;
    private final String authToken;
    private static final String API_BASE_URL = "https://api.sthan.io/AddressVerification/Usa/Single/";

    public AddressVerificationService(String authToken) {
        this.restTemplate = new RestTemplate();
        this.authToken = authToken;
    }

    public AddressVerificationResult verifyAddress(String addressString) {
        // URL encode the address
        String encodedAddress = UriUtils.encode(addressString, StandardCharsets.UTF_8);
        String url = API_BASE_URL + encodedAddress;

        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(authToken);

        HttpEntity<?> request = new HttpEntity<>(headers);

        ResponseEntity<AddressVerificationResult> response =
            restTemplate.exchange(url, HttpMethod.GET, request, AddressVerificationResult.class);

        return response.getBody();
    }
}

// Get auth token from Step 1
SthanAuthService authService = new SthanAuthService();
String token = authService.getAuthToken("your-profile-name", "your-profile-password");

// Usage example with Spring controller
@RestController
@RequestMapping("/api/address")
public class AddressController {

    private final AddressVerificationService verificationService;

    public AddressController() {
        // Get token from auth service and initialize verification service
        SthanAuthService authService = new SthanAuthService();
        String token = authService.getAuthToken(
            System.getenv("STHAN_PROFILE_NAME"),
            System.getenv("STHAN_PROFILE_PASSWORD")
        );
        this.verificationService = new AddressVerificationService(token);
    }

    @GetMapping("/verify")
    public ResponseEntity<AddressVerificationResult> verify(@RequestParam String address) {
        AddressVerificationResult result = verificationService.verifyAddress(address);
        return ResponseEntity.ok(result);
    }
}

For WordPress, Laravel, or PHP applications:

<?php

namespace App\Services;

use Illuminate\Support\Facades\Http;

class AddressVerificationService
{
    private $authToken;
    private $apiBaseUrl = 'https://api.sthan.io/AddressVerification/Usa/Single/';

    public function __construct(string $authToken)
    {
        $this->authToken = $authToken;
    }

    public function verifyAddress(string $addressString)
    {
        // URL encode the address
        $encodedAddress = urlencode($addressString);
        $url = $this->apiBaseUrl . $encodedAddress;

        $response = Http::withHeaders([
            'Authorization' => 'Bearer ' . $this->authToken
        ])->get($url);

        if ($response->successful()) {
            return $response->json();
        }

        throw new \Exception('Address verification failed: ' . $response->body());
    }
}

// Get auth token from Step 1
$authService = new SthanAuthService();
$token = $authService->getAuthToken(
    config('services.sthan.profile_name'),
    config('services.sthan.profile_password')
);

// Usage in controller
use App\Services\{AddressVerificationService, SthanAuthService};

class CheckoutController extends Controller
{
    public function validateAddress(Request $request)
    {
        // Get auth token
        $authService = new SthanAuthService();
        $token = $authService->getCachedToken() ?? $authService->getAuthToken(
            config('services.sthan.profile_name'),
            config('services.sthan.profile_password')
        );

        $service = new AddressVerificationService($token);

        // Combine address components into a single string
        $addressString = sprintf(
            '%s %s %s %s',
            $request->input('street'),
            $request->input('city'),
            $request->input('state'),
            $request->input('zip')
        );

        $result = $service->verifyAddress($addressString);

        return response()->json($result);
    }
}