JavaScript Email Name Extraction API

const https = require('https');

async function extractNamesFromEmail(email) {
    const url = `https://api.emailnameextractor.com/?q=${encodeURIComponent(email)}`;
    
    return new Promise((resolve, reject) => {
        https.get(url, (res) => {
            let data = '';
            res.on('data', chunk => data += chunk);
            res.on('end', () => resolve(JSON.parse(data)));
        }).on('error', reject);
    });
}

// Usage
const result = await extractNamesFromEmail('sarah.johnson@company.com');
console.log(`Name: ${result[0].firstName} ${result[0].lastName}`);
console.log(`Company: ${result[0].companyName}`);
console.log(`Confidence: ${result[0].confidence}%`);

const axios = require('axios');

class EmailNameExtractor {
    constructor() {
        this.baseURL = 'https://api.emailnameextractor.com';
    }

    async extractSingle(email) {
        const response = await axios.get(this.baseURL, {
            params: { q: email }
        });
        return response.data[0];
    }

    async extractBulk(emails) {
        const emailList = Array.isArray(emails) ? emails.join(',') : emails;
        const response = await axios.get(this.baseURL, {
            params: { q: emailList }
        });
        return response.data;
    }

    async extractWithCache(email, useCache = true) {
        const response = await axios.get(this.baseURL, {
            params: { 
                q: email,
                nocache: !useCache 
            }
        });
        return response.data[0];
    }
}

// Usage
const extractor = new EmailNameExtractor();

// Single email
const person = await extractor.extractSingle('james.wilson@tech.io');
console.log(person);

// Bulk processing
const people = await extractor.extractBulk([
    'alice@example.com',
    'bob.smith@company.com',
    'charlie.brown@startup.io'
]);
people.forEach(p => {
    console.log(`${p.firstName} ${p.lastName} - ${p.companyName}`);
});

import { useState, useCallback } from 'react';

export const useEmailNameExtractor = () => {
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState(null);
    const [data, setData] = useState(null);

    const extractName = useCallback(async (email) => {
        setLoading(true);
        setError(null);
        
        try {
            const response = await fetch(
                `https://api.emailnameextractor.com/?q=${encodeURIComponent(email)}`
            );
            
            if (!response.ok) {
                throw new Error('Failed to extract name');
            }
            
            const result = await response.json();
            setData(result[0]);
            return result[0];
            
        } catch (err) {
            setError(err.message);
            throw err;
        } finally {
            setLoading(false);
        }
    }, []);

    const extractBulk = useCallback(async (emails) => {
        setLoading(true);
        setError(null);
        
        try {
            const emailList = Array.isArray(emails) ? emails.join(',') : emails;
            const response = await fetch(
                `https://api.emailnameextractor.com/?q=${encodeURIComponent(emailList)}`
            );
            
            if (!response.ok) {
                throw new Error('Failed to extract names');
            }
            
            const results = await response.json();
            setData(results);
            return results;
            
        } catch (err) {
            setError(err.message);
            throw err;
        } finally {
            setLoading(false);
        }
    }, []);

    return { 
        extractName, 
        extractBulk, 
        loading, 
        error, 
        data 
    };
};

import React, { useState } from 'react';
import { useEmailNameExtractor } from './hooks/useEmailNameExtractor';

export const EmailExtractorForm = () => {
    const [email, setEmail] = useState('');
    const { extractName, loading, error, data } = useEmailNameExtractor();

    const handleSubmit = async (e) => {
        e.preventDefault();
        if (email) {
            await extractName(email);
        }
    };

    return (
        <div className="email-extractor">
            <form onSubmit={handleSubmit}>
                <div className="form-group">
                    <label htmlFor="email">Email Address</label>
                    <input
                        type="email"
                        id="email"
                        className="form-control"
                        value={email}
                        onChange={(e) => setEmail(e.target.value)}
                        placeholder="john.smith@example.com"
                        required
                    />
                </div>
                
                <button 
                    type="submit" 
                    className="btn btn-primary"
                    disabled={loading}
                >
                    {loading ? 'Extracting...' : 'Extract Name'}
                </button>
            </form>

            {error && (
                <div className="alert alert-danger mt-3">
                    Error: {error}
                </div>
            )}

            {data && (
                <div className="card mt-4">
                    <div className="card-body">
                        <h5 className="card-title">
                            {data.firstName} {data.lastName}
                        </h5>
                        <ul className="list-unstyled">
                            <li><strong>Email:</strong> {data.email}</li>
                            <li><strong>Company:</strong> {data.companyName}</li>
                            <li><strong>Confidence:</strong> {data.confidence}%</li>
                            <li><strong>AI Used:</strong> {data.aiUsed ? 'Yes' : 'No'}</li>
                        </ul>
                    </div>
                </div>
            )}
        </div>
    );
};