> ## Documentation Index
> Fetch the complete documentation index at: https://docs.airscale.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Email verifier

> Verify the deliverability of one email address. Rate limit: No endpoint-specific throttle.

Verify one email address using your workspace API key. Send exactly one `email` field in a JSON body of at most **16 KiB**. Surrounding whitespace is trimmed, and the trimmed address must be at most 320 characters. The legacy `/email-verifier` route remains available.

## Usage and credits

The cost is **0.5 credits per request**, reserved before verification. There is no endpoint-specific throttle.

When verification is pending, the API polls for up to **45 seconds** after the initial provider request without charging again. If pending verification cannot be resolved within that window, the effective result becomes `risky`. The initial provider request can itself take up to 90 seconds; allow time for both stages in your client timeout.

## Reading the response

Provider JSON object fields are preserved. A direct response receives `credits_consumed: 0.5` at the top level. If the provider uses a `body` wrapper, the result and `credits_consumed` remain inside `body`, and `returned_an_error` is set to `false`.

Fields such as `email`, `status`, and `result` are provider-dependent and may be absent. Non-object or non-JSON successful responses pass through unchanged without an added credit field.

## Errors and retries

Initial non-2xx provider responses retain the provider's status and body, such as `422`. The API attempts to refund the reservation for an initial provider error or network failure. If the refund cannot be confirmed, it returns `503`.

This endpoint does not support caller idempotency keys. Retrying creates another verification request and can incur another charge. Use bounded backoff for temporary failures and avoid treating a timeout as proof that no credits were charged.

## Next step

Use [Email finder](/api-reference/email-finder) to find a work email, or check your [credit balance](/api-reference/credit-count).


## OpenAPI

````yaml openapi.json POST /v1/email-verifier
openapi: 3.1.0
info:
  title: Airschool Public API
  version: '2026-09-11'
  description: Search, enrich, and resolve public business data with Airschool.
  x-airscale-source-repository: ViceScale/airscale-code
  x-airscale-source-sha: 1de19e1b70a052a4b8d9c2075021a7e5e7a94d51
servers:
  - url: https://api.airscale.io
    description: Production
security:
  - bearerAuth: []
tags:
  - name: Search and discovery
    description: Search people, companies, and the web.
  - name: Contact data
    description: Find professional and personal contact data.
  - name: Profiles and reverse lookup
    description: Extract profiles or resolve a person from known contact data.
  - name: Post engagement
    description: Retrieve and enrich people who liked or commented on LinkedIn posts.
  - name: Account
    description: Inspect workspace account state.
  - name: Miscellaneous
    description: Check WhatsApp availability, Meta ads, and email deliverability.
paths:
  /v1/email-verifier:
    post:
      tags:
        - Miscellaneous
      summary: Verify an email address
      description: >-
        Verify one email address for 0.5 credits. Pending verification is polled
        for up to 45 seconds after the initial provider request without another
        debit; unresolved pending results become risky. Provider JSON object
        fields and any body wrapper are preserved. The legacy /email-verifier
        route is also available. No caller idempotency key is supported.
      operationId: verifyEmail
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                email:
                  type: string
                  pattern: ^\s*[^\s@]+@[^\s@]+\.[^\s@]+\s*$
                  description: >-
                    One email address. Surrounding whitespace is trimmed; the
                    trimmed value must be at most 320 characters. Maximum JSON
                    body size: 16 KiB.
              required:
                - email
              additionalProperties: false
            examples:
              request:
                value:
                  email: person@example.com
      responses:
        '200':
          description: >-
            Normalized provider JSON object, either direct or wrapped in body.
            credits_consumed is added to the effective result object; other
            provider fields remain optional. Non-object or non-JSON successful
            provider responses are passed through unchanged under this same
            status.
          content:
            application/json:
              schema:
                anyOf:
                  - not:
                      type: object
                  - type: object
                    properties:
                      email:
                        description: >-
                          Email field preserved from the provider response, when
                          present.
                      status:
                        description: >-
                          Provider status, when present. Pending verification is
                          polled before returning.
                      result:
                        description: >-
                          Provider deliverability result, when present; risky is
                          used when pending verification cannot be resolved.
                      credits_consumed:
                        type: number
                        const: 0.5
                    required:
                      - credits_consumed
                    additionalProperties: true
                  - type: object
                    properties:
                      body:
                        type: object
                        properties:
                          email:
                            description: >-
                              Email field preserved from the provider response,
                              when present.
                          status:
                            description: >-
                              Provider status, when present. Pending
                              verification is polled before returning.
                          result:
                            description: >-
                              Provider deliverability result, when present;
                              risky is used when pending verification cannot be
                              resolved.
                          credits_consumed:
                            type: number
                            const: 0.5
                        required:
                          - credits_consumed
                        additionalProperties: true
                      returned_an_error:
                        type: boolean
                        const: false
                    required:
                      - body
                      - returned_an_error
                    additionalProperties: true
              examples:
                direct:
                  value:
                    email: person@example.com
                    result: deliverable
                    credits_consumed: 0.5
                wrapped:
                  value:
                    body:
                      email: person@example.com
                      status: success
                      result: risky
                      credits_consumed: 0.5
                    returned_an_error: false
            '*/*':
              schema: {}
        '400':
          description: >-
            Invalid JSON or body does not contain exactly one valid email field.
            Initial provider errors with this same status are passed through
            unchanged after an attempted refund; their body may differ.
          content:
            application/json:
              schema: {}
            '*/*':
              schema: {}
        '401':
          description: >-
            Missing or invalid bearer API key. Initial provider errors with this
            same status are passed through unchanged after an attempted refund;
            their body may differ.
          content:
            application/json:
              schema: {}
            '*/*':
              schema: {}
        '403':
          description: >-
            Insufficient credits. Initial provider errors with this same status
            are passed through unchanged after an attempted refund; their body
            may differ.
          content:
            application/json:
              schema: {}
            '*/*':
              schema: {}
        '413':
          description: >-
            JSON body exceeds 16 KiB. Initial provider errors with this same
            status are passed through unchanged after an attempted refund; their
            body may differ.
          content:
            application/json:
              schema: {}
            '*/*':
              schema: {}
        '500':
          description: >-
            Server configuration or unexpected server error. Initial provider
            errors with this same status are passed through unchanged after an
            attempted refund; their body may differ.
          content:
            application/json:
              schema: {}
            '*/*':
              schema: {}
        '502':
          description: >-
            Authentication lookup or provider network request failed. Initial
            provider errors with this same status are passed through unchanged
            after an attempted refund; their body may differ.
          content:
            application/json:
              schema: {}
            '*/*':
              schema: {}
        '503':
          description: >-
            Credit reservation or refund service is unavailable. Initial
            provider errors with this same status are passed through unchanged
            after an attempted refund; their body may differ.
          content:
            application/json:
              schema: {}
            '*/*':
              schema: {}
        default:
          description: >-
            Provider status and body are preserved for other responses,
            including initial non-2xx errors (for example 422). A refund is
            attempted for an initial non-2xx response. Non-object or non-JSON
            successful payloads also pass through unchanged, without an added
            credits_consumed field.
          content:
            application/json:
              schema: {}
            '*/*':
              schema: {}
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: API key
      description: >-
        Use an Airschool workspace API key. Never expose the key in client-side
        code.

````