SSL Certificate Lookup AI Agent / LLM

# SSL Certificate Lookup API — Way2API®

- **Endpoint:** `POST https://app.way2api.com/api/v1/domain/ssl`
- **Auth:** `Authorization: Bearer YOUR_API_KEY` (or `X-API-Key: YOUR_API_KEY`)
- **Content-Type:** `application/json`
- **Category:** Domain Intelligence and Analysis
- **Availability:** Available worldwide
- **Docs:** https://app.way2api.com/documentation/ssl-lookup

## What it does

SSL Certificate Lookup API — fetches the live TLS certificate chain presented by a domain. Each certificate reports its validity window, serial number, signature algorithm, subject and issuer, public-key algorithm and size, key usages, and the full list of SAN hostnames the certificate covers. Use valid_to for expiry monitoring and san_dns_names to confirm a certificate actually covers the host you are serving. Raw PEM blocks are omitted — the parsed fields carry the same information in usable form.

## Request body (application/json)

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `domain_name` | string | yes | Domain whose certificate should be fetched, e.g. example.com. A scheme, path or www. prefix is stripped automatically. |

## Example request

```bash
curl -X POST https://app.way2api.com/api/v1/domain/ssl \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain_name":"google.com"}'
```

## Success response — 200

```json
{
    "status": "SUCCESS",
    "status_code": 200,
    "charged": true,
    "success": true,
    "message": "",
    "message_code": "OK",
    "order_id": "W2A1739512345abcdef01",
    "data": {
        "order_id": "W2A1739512345abcdef01",
        "result": {
            "domain_name": "google.com",
            "certificates": [
                {
                    "chain_order": "end_user",
                    "authentication_type": "domain",
                    "valid_from": "2026-06-29 08:37:25 UTC",
                    "valid_to": "2026-09-21 08:37:24 UTC",
                    "serial_number": "02:b0:c1:99:b5:f2:ff:96:09:5e:3c:86:1a:f4:2b:ee",
                    "signature_algorithm": "SHA256-RSA",
                    "subject": {
                        "common_name": "*.google.com",
                        "organization": ""
                    },
                    "issuer": {
                        "common_name": "WR2",
                        "organization": "Google Trust Services",
                        "country": "US"
                    },
                    "public_key": {
                        "algorithm": "ECDSA",
                        "size": "256 bit"
                    },
                    "key_usages": [
                        "digital_signature"
                    ],
                    "extended_key_usages": [
                        "server_auth"
                    ],
                    "san_dns_names": [
                        "*.google.com",
                        "google.com",
                        "*.youtube.com"
                    ]
                }
            ],
            "queried_at": "2026-08-04 13:32:43"
        }
    }
}
```

## Error response — 400

```json
{
    "status": "FAILED",
    "status_code": 400,
    "charged": false,
    "success": false,
    "message": "Please pass domain param correct value",
    "message_code": "REQUEST_FAILED",
    "order_id": "W2A1739512345abcdef01",
    "data": {
        "order_id": "W2A1739512345abcdef01",
        "error_code": "Invalid Param Exception"
    }
}
```

## Integration rules

- Every response is JSON carrying `status`, `status_code`, `charged`, `success`, `message`, `message_code` and (once a call reaches the provider) `order_id`. The verification payload is under `data.result`.
- `charged` (boolean) is the authority on billing. Do NOT infer it from the HTTP status: `422` is returned both for input we rejected (not charged) and for a lookup the provider ran and billed us for that returned a negative result (charged).
- `message_code` is a fixed vocabulary — branch on it instead of parsing `message`. Values: `OK`, `ACCEPTED`, `PROVIDER_NO_RESPONSE`, `VERIFICATION_FAILED`, `NO_RECORD_FOUND`, `INVALID_INPUT`, `REQUEST_FAILED`, `MISSING_API_KEY`, `INVALID_API_KEY`, `INSUFFICIENT_BALANCE`, `NO_API_ACCESS`, `NOT_FOUND`, `RATE_LIMITED`, `INTERNAL_ERROR`, `PROVIDER_UNAVAILABLE`.
- `success` reports the verification outcome; `status` reports the ORDER lifecycle (`SUCCESS`/`PENDING`/`FAILED`). They differ on a charged negative result: the order completed and was billed while the verification did not pass.
- A failed verification is still a successful HTTP call — the outcome lives in the response body, so do not treat `200` as "verified".
- Status codes: `200` result returned, `202` pending or provider did not respond (both charged — quote the `order_id`), `401` missing/invalid key, `402` insufficient balance, `403` no access to this service, `422` see `charged`, `429` rate limited (honour the `Retry-After` header), `503` temporarily unavailable.
- Rate limits are per API key, per service, on a 1-minute sliding window.
- Load the API key from an environment variable or secret store. Never hard-code it, never commit it, and never ship it in client-side code — calls must be made from your backend.