# SSL Certificate Checker (`automation-lab/ssl-certificate-checker`) Actor

SSL Certificate Checker connects to domains over TLS and inspects their SSL certificates. It returns structured data about certificate validity, expiry, issuer chain, TLS protocol version, cipher suite, and a security grade from A+ to F.

- **URL**: https://apify.com/automation-lab/ssl-certificate-checker.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, SEO tools
- **Features:** Limited permissions
- **Stats:** 25 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 domain checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## SSL Certificate Checker

Check SSL/TLS certificates for any domain -- expiry dates, issuer, security grade (A+ to F), certificate chain, and protocol details.

### What does SSL Certificate Checker do?

**SSL Certificate Checker** connects to domains over TLS and inspects their SSL certificates. It returns structured data about certificate validity, expiry, issuer chain, TLS protocol version, cipher suite, and a security grade from A+ to F.

Use it to monitor certificate expiry across your domains, audit SSL configuration, verify certificate chains, or build alerts before certificates expire.

### Who is it for?

- **Certificate expiry monitoring** -- schedule weekly runs to catch expiring certificates before they cause downtime and browser warnings
- **Security auditing** -- verify SSL configuration, TLS version, and cipher suites across your infrastructure
- **Vendor assessment** -- check the SSL posture of third-party services and SaaS providers your organization depends on
- **Compliance reporting** -- generate certificate reports for PCI-DSS, SOC 2, or internal security policy requirements
- **Migration verification** -- confirm that certificate chains are valid after moving to new hosting or CDN providers

### Why use SSL Certificate Checker?

- **Security grading** -- A+ to F grade based on certificate validity, TLS version, and configuration gives you an instant overview
- **Expiry monitoring** -- days until expiry with severity levels (critical < 7 days, warning < 30 days) so you can prioritize action
- **Certificate chain** -- full chain from leaf to root CA for debugging trust issues
- **Protocol details** -- TLS version and cipher suite reported for each domain
- **Bulk checking** -- process hundreds of domains in a single run
- **URL cleaning** -- paste full URLs; protocols and paths are removed while `www` and other subdomains are preserved so the exact TLS endpoint is checked

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `domains` | array | Yes | -- | List of domain names or URLs to check. Protocols and paths are removed, hostnames are lowercased, and a trailing dot is ignored. Subdomains (including `www`) are preserved. Equivalent entries for the same exact hostname are deduplicated. |

#### Example input

```json
{
    "domains": ["apify.com", "google.com", "expired.badssl.com"]
}
```

### Recurring certificate monitoring

SSL checks are most valuable as a repeat job. Save your domain list and schedule a weekly run to catch certificates before they expire or fail validation. For high-risk production domains, run daily during migration windows or when `daysUntilExpiry` is below 30.

Example weekly monitoring input:

```json
{
    "domains": [
        "example.com",
        "api.example.com",
        "checkout.example.com"
    ]
}
```

Use Apify integrations to send failures to Slack or your incident tool. For a complete site-audit bundle, pair this actor with [Domain Age Checker](https://apify.com/automation-lab/domain-age-checker), [Sitemap URL Extractor](https://apify.com/automation-lab/sitemap-url-extractor), [Tech Stack Detector](https://apify.com/automation-lab/tech-stack-detector), and [Font Detector](https://apify.com/automation-lab/font-detector).

### Output example

Each domain produces one record with:

| Field | Description |
|-------|-------------|
| `domain` | The checked domain |
| `isValid` | Whether the certificate is trusted and not expired |
| `grade` | Security grade: A+, A, B, C, D, or F |
| `certificate` | Certificate details (subject, issuer, expiry, SANs, fingerprints) |
| `chain` | Certificate chain from leaf to root |
| `protocol` | TLS protocol version (e.g. TLSv1.3) |
| `cipher` | Cipher suite name |
| `issues` | Array of security issues with severity levels |
| `checkTimeMs` | Check duration in milliseconds |
| `error` | Error message if check failed |
| `checkedAt` | ISO timestamp |

```json
{
    "domain": "apify.com",
    "isValid": true,
    "grade": "A+",
    "certificate": {
        "subject": "CN=apify.com",
        "issuer": "CN=E6, O=Let's Encrypt, C=US",
        "validFrom": "2026-01-15T00:00:00.000Z",
        "validTo": "2026-04-15T00:00:00.000Z",
        "daysUntilExpiry": 45,
        "subjectAltNames": ["apify.com", "*.apify.com"]
    },
    "chain": [
        { "subject": "CN=E6, O=Let's Encrypt, C=US", "issuer": "CN=ISRG Root X2, O=Internet Security Research Group, C=US" }
    ],
    "protocol": "TLSv1.3",
    "cipher": "TLS_AES_256_GCM_SHA384",
    "issues": [],
    "checkTimeMs": 120,
    "error": null
}
```

### How to check SSL certificates for a domain

1. Go to [SSL Certificate Checker](https://apify.com/automation-lab/ssl-certificate-checker) on Apify Store
2. Enter one or more domain names in the `domains` field (e.g., `apify.com`, `google.com`)
3. Click **Start** to run the checker
4. Wait for results -- each domain is checked in milliseconds
5. Review the output for certificate validity, expiry dates, security grade, and TLS details
6. Download results as JSON, CSV, or Excel, or connect via API

### How much does it cost to check SSL certificates?

SSL Certificate Checker uses Apify's pay-per-event pricing. You only pay for what you use.

| Event | Cost |
|-------|------|
| Run start | $0.035 |
| Per domain checked | $0.001 |

**Cost examples:**

- 5 domains: $0.035 + 5 x $0.001 = **$0.04**
- 100 domains: $0.035 + 100 x $0.001 = **$0.135**
- 1,000 domains: $0.035 + 1,000 x $0.001 = **$1.035**

### API usage

You can start SSL Certificate Checker programmatically using the Apify API. Replace `YOUR_TOKEN` with your [Apify API token](https://console.apify.com/settings/integrations).

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation-lab/ssl-certificate-checker').call({
    domains: ['apify.com', 'google.com'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/ssl-certificate-checker').call(run_input={
    'domains': ['apify.com', 'google.com'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~ssl-certificate-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"domains": ["apify.com", "google.com"]}'
```

### Use with AI agents via MCP

SSL Certificate Checker is available as a tool for AI assistants via the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/ssl-certificate-checker"
```

#### Setup for Claude Desktop, Cursor, or VS Code

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/ssl-certificate-checker"
        }
    }
}
```

#### Example prompts

- "When does the SSL certificate for example.com expire?"
- "Check SSL certificates for all our domains"
- "Grade the SSL security of these vendor websites"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Integrations

Connect SSL Certificate Checker with other tools using [Apify integrations](https://apify.com/integrations). Set up webhooks to get alerts when certificates are about to expire. Export results to Google Sheets for infrastructure tracking, send Slack notifications when grades drop below a threshold, trigger Make or Zapier workflows for automated certificate management, or push data to n8n for custom monitoring pipelines.

### Grading scale

| Grade | Description |
|-------|-------------|
| A+ | Excellent -- TLS 1.3, valid certificate, strong cipher, long validity |
| A | Good -- valid certificate, modern TLS, minor configuration gaps |
| B | Fair -- valid certificate but older TLS version or weaker cipher |
| C | Below average -- certificate issues or outdated protocol |
| D | Poor -- significant problems such as weak ciphers or short validity |
| F | Failing -- expired, self-signed, untrusted, or unreachable |

### Tips and best practices

- **Monitor expiry** -- schedule weekly runs to catch certificates before they expire and cause downtime.
- **Test with badssl.com** -- use `expired.badssl.com`, `self-signed.badssl.com` to verify detection works as expected.
- **Grade interpretation** -- A+ means TLS 1.3, trusted, long validity. F means expired, untrusted, or connection failed.
- **Filter by daysUntilExpiry** to prioritize domains that need immediate attention (under 30 days).
- **Combine with HTTP Headers Security Checker** for a complete security audit covering both certificate health and header configuration.

### Legality

Yes. SSL Certificate Checker only examines publicly visible TLS/SSL certificate information that any browser retrieves during the standard HTTPS handshake. No authentication is bypassed, and no private data is accessed.

SSL certificate inspection is a standard security practice used by IT teams, security auditors, and compliance officers worldwide. Certificate details are intentionally public — they must be to enable trust verification.

Key points:

- Only publicly available certificate data is analyzed
- The tool performs the same handshake as any web browser
- Certificate transparency is a core principle of internet security
- No private systems or data are accessed

For more details, see the [Apify guide on ethical web scraping](https://docs.apify.com/academy/expert-scraping-with-apify/anti-scraping-protections).

### FAQ

**What security grades are possible?**
Grades range from A+ (excellent -- TLS 1.3, valid certificate, strong cipher) down to F (expired, self-signed, or unreachable). The grading considers TLS version, certificate validity, chain completeness, and cipher strength.

**Can I check internal or private domains?**
The actor connects to domains over the public internet. Internal domains that are not publicly reachable cannot be checked.

**Does it check for certificate transparency logs?**
The actor focuses on certificate validity, chain verification, and TLS configuration. Certificate transparency log checking is not currently included.

**A domain I know is valid gets a grade of F. Why?**
An F grade can result from several issues: the certificate is expired, self-signed, issued for a different domain, or the server is unreachable on port 443. Check the `issues` array in the output for specific details. If the site works in your browser, the server may be blocking connections from cloud IP ranges.

**The actor shows TLSv1.2 instead of TLSv1.3. Is that a problem?**
TLS 1.2 is still considered secure and widely used. However, TLS 1.3 is faster and more secure, which is why it receives a higher grade. If your server supports TLS 1.3 but the actor reports 1.2, the server's configuration may prefer 1.2 for certain clients. Check your server's TLS configuration to ensure 1.3 is enabled and preferred.

### Related DNS and security tools

- [Domain Age Checker](https://apify.com/automation-lab/domain-age-checker) -- Check domain registration age
- [WHOIS Lookup](https://apify.com/automation-lab/whois-lookup) -- Domain registration and ownership data
- [DNS Lookup](https://apify.com/automation-lab/dns-lookup) -- General DNS record lookup
- [Subdomain Finder](https://apify.com/automation-lab/subdomain-finder) -- Discover subdomains via certificate transparency logs
- [SPF Record Checker](https://apify.com/automation-lab/spf-record-checker) -- Check SPF email authentication records
- [DMARC Record Checker](https://apify.com/automation-lab/dmarc-record-checker) -- Check DMARC email policies
- [MX Record Checker](https://apify.com/automation-lab/mx-record-checker) -- Look up mail exchange records

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/ssl-certificate-checker/changelog.md

# Actor input Schema

## `domains` (type: `array`):

List of domain names or URLs to check. Protocols and paths are removed, hostnames are lowercased, and trailing dots are ignored. Subdomains (including www) are preserved. Equivalent entries for the same exact hostname are deduplicated.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "google.com",
    "expired.badssl.com"
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

Table view of SSL certificate check results.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "apify.com",
        "google.com",
        "expired.badssl.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ssl-certificate-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "domains": [
        "apify.com",
        "google.com",
        "expired.badssl.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ssl-certificate-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "apify.com",
    "google.com",
    "expired.badssl.com"
  ]
}' |
apify call automation-lab/ssl-certificate-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ssl-certificate-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/fSAH5aNEOOewIWMiO/builds/FH8a8uFbTwiScF5CH/openapi.json
