> This page is for Documentation, version Integration guides (default).
> For other versions, use one of these documentation indexes:
> - Integration guides (default): https://avalara.ferndocs.com/docs/integration-guides/llms.txt
> - Refactor guides: https://avalara.ferndocs.com/docs/refactor-guides/llms.txt
> - Get certified: https://avalara.ferndocs.com/docs/get-certified/llms.txt
> - Agent to Agent (A2A): https://avalara.ferndocs.com/docs/agent-to-agent-a2a/llms.txt
> - AI use cases: https://avalara.ferndocs.com/docs/ai-use-cases/llms.txt
> - API versioning: https://avalara.ferndocs.com/docs/api-versioning/llms.txt

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

# Validate addresses

US sales tax is jurisdiction-specific, and jurisdictions don't follow ZIP code boundaries. Resolving an address before you calculate ensures AvaTax assigns the correct state, county, city, and special district rates.

## Resolve an address

`POST /api/v2/addresses/resolve` validates an address, corrects it to a standardized form, and returns latitude/longitude plus the tax authorities that apply.

### Request

POST [https://rest.avatax.com/api/v2/addresses/resolve](https://rest.avatax.com/api/v2/addresses/resolve)

```curl
curl -X POST https://rest.avatax.com/api/v2/addresses/resolve \
     -H "Authorization: <apiKey>" \
     -H "Content-Type: application/json-patch+json" \
     -d '{
  "line1": "2000 Main Street",
  "textCase": "Upper",
  "city": "Irvine",
  "region": "CA",
  "country": "US",
  "postalCode": "92614"
}'
```

```typescript
import { AvalaraClient } from "avalara";

async function main() {
    const client = new AvalaraClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.avatax.addresses.resolveAddressPost({
        line1: "2000 Main Street",
        textCase: "Upper",
        city: "Irvine",
        region: "CA",
        country: "US",
        postalCode: "92614",
    });
}
main();

```

```python
from avalara import Avalara

client = Avalara(
    api_key="YOUR_API_KEY_HERE",
)

client.avatax.addresses.resolve_address_post(
    line1="2000 Main Street",
    text_case="Upper",
    city="Irvine",
    region="CA",
    country="US",
    postal_code="92614",
)

```

```go
package main

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

func main() {

	url := "https://rest.avatax.com/api/v2/addresses/resolve"

	payload := strings.NewReader("{\n  \"line1\": \"2000 Main Street\",\n  \"textCase\": \"Upper\",\n  \"city\": \"Irvine\",\n  \"region\": \"CA\",\n  \"country\": \"US\",\n  \"postalCode\": \"92614\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "<apiKey>")
	req.Header.Add("Content-Type", "application/json-patch+json")

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

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

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

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://rest.avatax.com/api/v2/addresses/resolve")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json-patch+json'
request.body = "{\n  \"line1\": \"2000 Main Street\",\n  \"textCase\": \"Upper\",\n  \"city\": \"Irvine\",\n  \"region\": \"CA\",\n  \"country\": \"US\",\n  \"postalCode\": \"92614\"\n}"

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://rest.avatax.com/api/v2/addresses/resolve")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json-patch+json")
  .body("{\n  \"line1\": \"2000 Main Street\",\n  \"textCase\": \"Upper\",\n  \"city\": \"Irvine\",\n  \"region\": \"CA\",\n  \"country\": \"US\",\n  \"postalCode\": \"92614\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://rest.avatax.com/api/v2/addresses/resolve', [
  'body' => '{
  "line1": "2000 Main Street",
  "textCase": "Upper",
  "city": "Irvine",
  "region": "CA",
  "country": "US",
  "postalCode": "92614"
}',
  'headers' => [
    'Authorization' => '<apiKey>',
    'Content-Type' => 'application/json-patch+json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://rest.avatax.com/api/v2/addresses/resolve");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json-patch+json");
request.AddParameter("application/json-patch+json", "{\n  \"line1\": \"2000 Main Street\",\n  \"textCase\": \"Upper\",\n  \"city\": \"Irvine\",\n  \"region\": \"CA\",\n  \"country\": \"US\",\n  \"postalCode\": \"92614\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json-patch+json"
]

let postData = NSData(data: "{
  "line1": "2000 Main Street",
  "textCase": "Upper",
  "city": "Irvine",
  "region": "CA",
  "country": "US",
  "postalCode": "92614"
}".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "https://rest.avatax.com/api/v2/addresses/resolve")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```

**`Request`**

```json title="Request"
{
  "line1": "88 garden ave",
  "city": "denver",
  "region": "CO",
  "postalCode": "80202",
  "country": "US"
}
```

## Response

The `validatedAddresses` array contains the corrected address; `coordinates` returns the geocode; and `taxAuthorities` lists the jurisdictions that will be applied during calculation.

### Response (200)

```json
{
  "address": {
    "line1": "2000 Main Street",
    "city": "Irvine",
    "region": "CA",
    "country": "US",
    "postalCode": "92614"
  },
  "coordinates": {
    "latitude": 33.684884,
    "longitude": -117.851321
  },
  "resolutionQuality": "Intersection",
  "taxAuthorities": [
    {
      "jurisdictionName": "CALIFORNIA",
      "avalaraId": "AGAM",
      "jurisdictionType": "State",
      "signatureCode": "AGAM"
    }
  ],
  "messages": [
    {
      "summary": "The address is not deliverable.",
      "details": "The physical location exists but there are no homes on this street. One reason might be railroad tracks or rivers running alongside this street, as they would prevent construction of homes in this location.",
      "refersTo": "address",
      "severity": "Error",
      "source": "Avalara.AvaTax.Services.Address"
    }
  ]
}
```

## Interpreting messages

The `messages` array flags anything AvaTax changed or couldn't confirm.

#### Address corrected

A `refinementLevel` at the rooftop or ZIP+4 level means the address resolved cleanly. Store the validated form for future orders.

#### Address not found

A message with severity `Error` means the address couldn't be matched. Prompt the customer to re-enter it rather than calculating against an unverified location.

> **Tip**
>
> Validate at address entry — in the checkout form — not at calculation time. Correcting the address once avoids repeated round-trips and keeps every downstream transaction accurate.