Learn how to integrate VerifyVAT

1
VERIFYVAT_SECRET_KEY=sk_demo_00000000000000000000000000000000

1
/**
2
 * Verify if a tax ID is valid and retrieve business details
3
 * @param taxId The tax ID to verify
4
 * @return business details if the tax ID is valid, false if not, null in case of error
5
 */
6
export async function getTaxIdDetails(taxId: string) {
7
    // Change this to the appropriate tax type
8
    const taxType = 'auto'
9
    // Sanitize the tax ID
10
    const sanitizedTaxId = taxId.replace(/[^a-zA-Z0-9]/g, '')
11
    try {
12
        const endpoint = `https://verifyvat.com/api/${taxType}/${sanitizedTaxId}`
13
        const query = await fetch(endpoint, {
14
            method: 'POST',
15
            headers: {
16
                'Content-Type': 'application/json',
17
                'x-api-key': process.env.VERIFYVAT_SECRET_KEY!,
18
            },
19
        })
20

21
        if (!query.ok) {
22
            // If we encounter an error at this stage,
23
            // it means there is a connection issue with the API
24
            throw new Error('Network response was not ok')
25
        }
26

27
        const response = await query.json()
28
        if (response.error) {
29
            // If the API returns an error, handle it here
30
            // For example, we might want to check the error code
31
            // and provide a more detailed message
32
            throw new Error(response.message)
33
        }
34
        if (!response.data) {
35
            // If the response does not contain data, even if the request was successful
36
            // it means there has been an issue with our request
37
            throw new Error('Unexpected error occured during the request')
38
        }
39

40
        if (!response.data.isValid) {
41
            // The tax ID is not valid
42
            return false
43
        }
44

45
        // The tax ID is valid, return the business details
46
        const { businessName = '', fullAddress = '', countryCode = '' } = response.data
47
        return {
48
            businessName,
49
            fullAddress,
50
            countryCode,
51
        }
52
    } catch (error) {
53
        console.error('Error fetching tax ID data:', error)
54
        return null
55
    }
56
}

1
import { getTaxIdDetails } from './api'
2

3
export async function main() {
4
    // Change this to the tax ID you want to verify
5
    const taxId = 'NO 995 525 828 MVA'
6
    const taxIdDetails = await getTaxIdDetails(taxId)
7
    if (taxIdDetails) {
8
        console.log(`Tax ID "${taxId}" is valid.`)
9
        console.log(`Business Name: ${taxIdDetails.businessName}`)
10
        console.log(`Full Address: ${taxIdDetails.fullAddress}`)
11
        console.log(`Country Code: ${taxIdDetails.countryCode}`)
12
    } else if (taxIdDetails === false) {
13
        console.log(`Tax ID "${taxId}" is not valid.`)
14
    } else {
15
        console.log(`Could not retrieve tax ID status for "${taxId}".`)
16
    }
17
}
18
main()

1
import { z } from 'zod'
2

3
export const ResponseDataShape = z.object({
4
    id: z.string(),
5
    type: z.string(),
6
    formattedId: z.string(),
7
    typeName: z.string(),
8
    isValid: z.boolean(),
9
    isVerified: z.boolean(),
10
    isPatternOnly: z.boolean(),
11
    isVerifiable: z.boolean(),
12
    manualDataSource: z.string().optional(),
13
    dataSource: z.string().optional(),
14
    firstName: z.string().optional(),
15
    lastName: z.string().optional(),
16
    fullName: z.string().optional(),
17
    birthDate: z.string().optional(),
18
    gender: z.string().optional(),
19
    birthPlace: z.string().optional(),
20
    birthCountryCode: z.string().optional(),
21
    businessName: z.string().optional(),
22
    alternativeName: z.string().optional(),
23
    businessType: z.string().optional(),
24
    businessStatus: z.string().optional(),
25
    registrationDate: z.string().optional(),
26
    dissolutionDate: z.string().optional(),
27
    isVatRegistered: z.boolean().optional(),
28
    address: z.string().optional(),
29
    postalCode: z.string().optional(),
30
    town: z.string().optional(),
31
    region: z.string().optional(),
32
    countryCode: z.string().optional(),
33
    fullAddress: z.string().optional(),
34
    alternativeIdentifiers: z
35
        .array(
36
            z.object({
37
                country: z.string(),
38
                type: z.string().optional(),
39
                id: z.string(),
40
            }),
41
        )
42
        .optional(),
43
})
44

45
export const ResponseShape = z.object({
46
    error: z.boolean(),
47
    message: z.string(),
48
    status: z.number(),
49
    data: ResponseDataShape.nullable(),
50
    timestamp: z.number(),
51
    eventId: z.string().nullable(),
52
    code: z.string().nullable(),
53
    overQuota: z.boolean(),
54
})
55

56
export type VerifyVATData = z.infer<typeof ResponseDataShape>
57
export type VerifyVATResponse = z.infer<typeof ResponseShape>