Build with IntoDNS.AI

name: DNS Validation
on: [push]
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - name: Check DNS Security
        run: |
          SCORE=$(curl -s \
            "https://intodns.ai/api/scan/quick?domain=$DOMAIN" \
            | jq -r '.score')
          if [ "$SCORE" -lt 80 ]; then
            echo "DNS score too low: $SCORE"
            exit 1
          fi
        env:
          DOMAIN: ${{ secrets.DOMAIN }}

dns-check:
  script:
    - apk add --no-cache curl jq
    - RESULT=$(curl -s "https://intodns.ai/api/scan/quick?domain=$DOMAIN")
    - SCORE=$(echo $RESULT | jq -r '.score')
    - if [ "$SCORE" -lt 80 ]; then exit 1; fi
  only:
    - main

const cron = require('node-cron');
const axios = require('axios');

// Check every 6 hours
cron.schedule('0 */6 * * *', async () => {
  const { data } = await axios.get(
    'https://intodns.ai/api/scan/quick?domain=example.com'
  );

  if (data.critical_issues > 0) {
    await sendAlert({
      severity: 'critical',
      message: `Domain has ${data.critical_issues} issues`,
      details: data.categories
    });
  }
});

import requests
import smtplib

def check_domain(domain):
    r = requests.get(f'https://intodns.ai/api/scan/quick?domain={domain}')
    data = r.json()

    if data['critical_issues'] > 0:
        send_alert(f"Critical issues found for {domain}")

    return data['score']

if __name__ == '__main__':
    score = check_domain('example.com')
    print(f'Domain score: {score}')

async function validateDomain(domain: string) {
  try {
    const response = await fetch(
      `https://intodns.ai/api/scan/quick?domain=${domain}`
    );
    const data = await response.json();

    // Check minimum requirements
    const issues = [];

    if (data.score < 70) {
      issues.push('Security score below minimum');
    }

    if (data.critical_issues > 0) {
      issues.push('Critical security issues present');
    }

    if (!data.categories.email || data.categories.email.score < 60) {
      issues.push('Email security insufficient');
    }

    return {
      valid: issues.length === 0,
      issues,
      score: data.score
    };
  } catch (error) {
    return { valid: false, issues: ['Domain unreachable'] };
  }
}

import requests
import time
from typing import List, Dict

def validate_domains(domains: List[str]) -> List[Dict]:
    results = []

    for domain in domains:
        try:
            response = requests.get(
                f'https://intodns.ai/api/scan/quick?domain={domain}',
                timeout=30
            )
            data = response.json()

            results.append({
                'domain': domain,
                'score': data.get('score', 0),
                'status': 'success',
                'critical_issues': data.get('critical_issues', 0)
            })

            # Respect rate limits: 10 req/min for free tier
            time.sleep(6)

        except Exception as e:
            results.append({
                'domain': domain,
                'status': 'error',
                'error': str(e)
            })

    return results

# Example usage
domains = ['example.com', 'test.com', 'demo.org']
results = validate_domains(domains)

for result in results:
    if result['status'] == 'success':
        print(f"{result['domain']}: {result['score']}/100")
    else:
        print(f"{result['domain']}: ERROR - {result['error']}")