рдИрдореЗрд▓ рдкрддреЗ рдПрдХрддреНрд░ рдХрд░рдиреЗ рд╡рд╛рд▓реЗ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдмрдирд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдбреЗрдЯрд╛ рдЧреБрдгрд╡рддреНрддрд╛ рдмрдирд╛рдП рд░рдЦрдиреЗ рдФрд░ рдЕрдкрдиреА sender reputation рдХреЛ рд╕реБрд░рдХреНрд╖рд┐рдд рд░рдЦрдиреЗ рдХреЗ рд▓рд┐рдП рдордЬрдмреВрдд рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИред Node.js developers рдХреЗ рдкрд╛рд╕ рдЕрдкрдиреЗ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдореЗрдВ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рд╕реЗрд╡рд╛рдУрдВ рдХреЛ рдПрдХреАрдХреГрдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рд╢рдХреНрддрд┐рд╢рд╛рд▓реА рдЯреВрд▓реНрд╕ рдЙрдкрд▓рдмреНрдз рд╣реИрдВред рдпрд╣ рд╡реНрдпрд╛рдкрдХ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рдЖрдкрдХреЛ рдмреБрдирд┐рдпрд╛рджреА рд╕реЗрдЯрдЕрдк рд╕реЗ рд▓реЗрдХрд░ рдкреНрд░реЛрдбрдХреНрд╢рди-рд░реЗрдбреА рдЗрдореНрдкреНрд▓реАрдореЗрдВрдЯреЗрд╢рди рддрдХ Node.js рдХреЗ рд╕рд╛рде рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди API рдПрдХреАрдХрд░рдг рдХреЛ рд▓рд╛рдЧреВ рдХрд░рдиреЗ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдорд╛рд░реНрдЧрджрд░реНрд╢рди рдХрд░рддрд╛ рд╣реИред
рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдПрдХреАрдХрд░рдг рдХреЗ рд▓рд┐рдП Node.js рдХреНрдпреЛрдВ
Node.js рдЖрдзреБрдирд┐рдХ рд╡реЗрдм рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдмрдирд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдкрд╕рдВрджреАрджрд╛ рд░рдирдЯрд╛рдЗрдо рдмрди рдЧрдпрд╛ рд╣реИ, рдФрд░ рдЗрд╕рдХреА asynchronous рдкреНрд░рдХреГрддрд┐ рдЗрд╕реЗ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдЬреИрд╕реЗ API рдПрдХреАрдХрд░рдг рдХреЗ рд▓рд┐рдП рд╡рд┐рд╢реЗрд╖ рд░реВрдк рд╕реЗ рдЙрдкрдпреБрдХреНрдд рдмрдирд╛рддреА рд╣реИред рдЬрдм рдпреВрдЬрд╝рд░реНрд╕ рдЖрдкрдХреЗ рдлреЙрд░реНрдо рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рдИрдореЗрд▓ рдкрддреЗ рд╕рдмрдорд┐рдЯ рдХрд░рддреЗ рд╣реИрдВ, рддреЛ рдЖрдкрдХреЛ рддреЗрдЬрд╝, non-blocking рд╕рддреНрдпрд╛рдкрди рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИ рдЬреЛ рдпреВрдЬрд╝рд░ рдЕрдиреБрднрд╡ рдХреЛ рдзреАрдорд╛ рди рдХрд░реЗред Node.js рдХрдИ concurrent API requests рдХреЛ рдХреБрд╢рд▓рддрд╛ рд╕реЗ рд╕рдВрднрд╛рд▓рдиреЗ рдореЗрдВ рдЙрддреНрдХреГрд╖реНрдЯ рд╣реИ, рдЬреЛ рдЗрд╕реЗ real-time single email verification рдФрд░ batch processing рджреЛрдиреЛрдВ рдкрд░рд┐рджреГрд╢реНрдпреЛрдВ рдХреЗ рд▓рд┐рдП рдЖрджрд░реНрд╢ рдмрдирд╛рддрд╛ рд╣реИред E-commerce applications рдХреЗ рд▓рд┐рдП, E-commerce Implementation Guide рджреЗрдЦреЗрдВред
npm ecosystem рдЙрддреНрдХреГрд╖реНрдЯ HTTP client libraries рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИ рдЬреЛ API рдПрдХреАрдХрд░рдг рдХреЛ рд╕рд░рд▓ рдмрдирд╛рддреА рд╣реИрдВред рдЪрд╛рд╣реЗ рдЖрдк built-in fetch API, axios, рдпрд╛ node-fetch рдХреЛ рдкрд╕рдВрдж рдХрд░реЗрдВ, Node.js рдореЗрдВ рдИрдореЗрд▓ рд╡реИрд▓рд┐рдбреЗрдЯрд░ рдХреЛ рд▓рд╛рдЧреВ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдиреНрдпреВрдирддрдо boilerplate code рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИ рдЬрдмрдХрд┐ customization рдХреЗ рд▓рд┐рдП рдЕрдзрд┐рдХрддрдо flexibility рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИред
рдЕрдкрдирд╛ Node.js рдкреНрд░реЛрдЬреЗрдХреНрдЯ рд╕реЗрдЯрдЕрдк рдХрд░рдирд╛
рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди implementation рдореЗрдВ рдЬрд╛рдиреЗ рд╕реЗ рдкрд╣рд▓реЗ, рд╕реБрдирд┐рд╢реНрдЪрд┐рдд рдХрд░реЗрдВ рдХрд┐ рдЖрдкрдХрд╛ development environment рдареАрдХ рд╕реЗ configured рд╣реИред рдЖрдкрдХреЛ native fetch API рдХрд╛ рд▓рд╛рдн рдЙрдард╛рдиреЗ рдХреЗ рд▓рд┐рдП Node.js рд╕рдВрд╕реНрдХрд░рдг 18 рдпрд╛ рдЙрдЪреНрдЪрддрд░ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрдЧреА, рд╣рд╛рд▓рд╛рдВрдХрд┐ рдкрд╣рд▓реЗ рдХреЗ рд╕рдВрд╕реНрдХрд░рдг polyfill рдХреЗ рд░реВрдк рдореЗрдВ node-fetch рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред
рдирд┐рд░реНрднрд░рддрд╛рдУрдВ рдХреЛ рдЗрдВрд╕реНрдЯреЙрд▓ рдХрд░рдирд╛
рдПрдХ рдирдИ рдкреНрд░реЛрдЬреЗрдХреНрдЯ рдбрд╛рдпрд░реЗрдХреНрдЯрд░реА рдмрдирд╛рдПрдВ рдФрд░ рдЗрд╕реЗ npm рдХреЗ рд╕рд╛рде initialize рдХрд░реЗрдВред рдЖрдкрдХреЗ package.json рдореЗрдВ HTTP requests рдФрд░ environment variable management рдХреЗ рд▓рд┐рдП рдЖрд╡рд╢реНрдпрдХ dependencies рд╢рд╛рдорд┐рд▓ рд╣реЛрдиреА рдЪрд╛рд╣рд┐рдПред dotenv package рдЖрдкрдХреА API credentials рдХреЛ source code рдореЗрдВ hardcode рдХрд░рдиреЗ рдХреЗ рдмрдЬрд╛рдп environment files рд╕реЗ load рдХрд░рдХреЗ рдЙрдиреНрд╣реЗрдВ рд╕реБрд░рдХреНрд╖рд┐рдд рд░рдЦрдиреЗ рдореЗрдВ рдорджрдж рдХрд░рддрд╛ рд╣реИред
// package.json
{
"name": "email-verification-demo",
"version": "1.0.0",
"type": "module",
"dependencies": {
"dotenv": "^16.3.1"
}
}
рдПрдирд╡рд╛рдпрд░рдирдореЗрдВрдЯ рд╡реЗрд░рд┐рдПрдмрд▓реНрд╕ рдХреЛ рдХреЙрдиреНрдлрд╝рд┐рдЧрд░ рдХрд░рдирд╛
рдЕрдкрдиреА BillionVerify API key рдХреЛ рдПрдХ environment file рдореЗрдВ рд╕реНрдЯреЛрд░ рдХрд░реЗрдВред рдХрднреА рднреА API keys рдХреЛ version control рдореЗрдВ commit рди рдХрд░реЗрдВред .env file credentials рдХреЛ рдЖрдкрдХреЗ codebase рд╕реЗ рдЕрд▓рдЧ рд░рдЦрддреА рд╣реИ, рдЙрди рд╕реБрд░рдХреНрд╖рд╛ best practices рдХрд╛ рдкрд╛рд▓рди рдХрд░рддреЗ рд╣реБрдП рдЬрд┐рдирдХреА рд╣рд░ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рд╕реЗрд╡рд╛ рд╕рд┐рдлрд╛рд░рд┐рд╢ рдХрд░рддреА рд╣реИред
# .env BILLIONVERIFY_API_KEY=your_api_key_here
рдПрдХрд▓ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рд▓рд╛рдЧреВ рдХрд░рдирд╛
рдХрд┐рд╕реА рднреА рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдПрдХреАрдХрд░рдг рдХреА рдиреАрдВрд╡ рд╡реНрдпрдХреНрддрд┐рдЧрдд рдИрдореЗрд▓ рдкрддреЛрдВ рдХреЛ рд╕рддреНрдпрд╛рдкрд┐рдд рдХрд░рдиреЗ рдХреА рдХреНрд╖рдорддрд╛ рд╣реИред рдпрд╣ functionality рдпреВрдЬрд╝рд░ рдкрдВрдЬреАрдХрд░рдг, contact form submissions, рдФрд░ рдХрд┐рд╕реА рднреА рдкрд░рд┐рджреГрд╢реНрдп рдХреЗ рджреМрд░рд╛рди real-time validation рдХреЛ рд╢рдХреНрддрд┐ рджреЗрддреА рд╣реИ рдЬрд╣рд╛рдВ рддрддреНрдХрд╛рд▓ feedback рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИред
рдЕрдкрдирд╛ рдкрд╣рд▓рд╛ API рдХреЙрд▓ рдХрд░рдирд╛
BillionVerify рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди API request body рдореЗрдВ рдИрдореЗрд▓ рдкрддреЗ рдХреЗ рд╕рд╛рде POST requests рдХреЛ рд╕реНрд╡реАрдХрд╛рд░ рдХрд░рддрд╛ рд╣реИред Response рдореЗрдВ рд╡реНрдпрд╛рдкрдХ рд╕рддреНрдпрд╛рдкрди рдкрд░рд┐рдгрд╛рдо рд╢рд╛рдорд┐рд▓ рд╣реЛрддреЗ рд╣реИрдВ рдЬрд┐рдирдореЗрдВ validity status, deliverability assessment, рдФрд░ disposable emails, role-based addresses, рдФрд░ catch-all domains рдХреЗ рд▓рд┐рдП рд╡рд┐рд╕реНрддреГрдд рдЬрд╛рдВрдЪ рд╢рд╛рдорд┐рд▓ рд╣реИрдВред
// verify-email.js
import 'dotenv/config';
const API_BASE_URL = 'https://api.billionverify.com/v1';
const API_KEY = process.env.BILLIONVERIFY_API_KEY;
async function verifyEmail(email) {
const response = await fetch(`${API_BASE_URL}/verify`, {
method: 'POST',
headers: {
'Authorization': `Bearer ${API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ email })
});
if (!response.ok) {
throw new Error(`Verification failed: ${response.status}`);
}
return response.json();
}
// Usage example
const result = await verifyEmail('user@example.com');
console.log(result);
рд░рд┐рд╕реНрдкреЙрдиреНрд╕ рдлрд╝реАрд▓реНрдб рдХреЛ рд╕рдордЭрдирд╛
рд╕рддреНрдпрд╛рдкрди response рдкреНрд░рддреНрдпреЗрдХ рдИрдореЗрд▓ рдкрддреЗ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ actionable intelligence рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИред рдЗрди response fields рдХреЛ рд╕рдордЭрдирд╛ рдЖрдкрдХреЛ рдЕрдкрдиреЗ рд╕рд┐рд╕реНрдЯрдо рдореЗрдВ рдИрдореЗрд▓ рдкрддрд╛ рд╕реНрд╡реАрдХрд╛рд░ рдХрд░рдиреЗ рдпрд╛ рдЕрд╕реНрд╡реАрдХрд╛рд░ рдХрд░рдиреЗ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рд╕реВрдЪрд┐рдд рдирд┐рд░реНрдгрдп рд▓реЗрдиреЗ рдореЗрдВ рдорджрдж рдХрд░рддрд╛ рд╣реИред
| Field | Description | Use Case |
|---|---|---|
| is_valid | рд╕рдордЧреНрд░ validity assessment | рдкреНрд░рд╛рдердорд┐рдХ accept/reject рдирд┐рд░реНрдгрдп |
| is_deliverable | рдИрдореЗрд▓ рдкреНрд░рд╛рдкреНрдд рдХрд░ рд╕рдХрддрд╛ рд╣реИ | рдИрдореЗрд▓ campaign eligibility |
| is_disposable | рдЕрд╕реНрдерд╛рдпреА рдИрдореЗрд▓ рд╕реЗрд╡рд╛ | рдзреЛрдЦрд╛рдзрдбрд╝реА рдХреА рд░реЛрдХрдерд╛рдо |
| is_role_based | рд╕рд╛рдорд╛рдиреНрдп рдкрддрд╛ (info@, support@) | B2B targeting |
| is_catch_all | Domain рд╕рднреА рдкрддреЛрдВ рдХреЛ рд╕реНрд╡реАрдХрд╛рд░ рдХрд░рддрд╛ рд╣реИ | рдЬреЛрдЦрд┐рдо рдореВрд▓реНрдпрд╛рдВрдХрди |
| risk_score | 0-100 рдЬреЛрдЦрд┐рдо рд░реЗрдЯрд┐рдВрдЧ | рд╕реВрдХреНрд╖реНрдо filtering |
рдПрдХ рдкреБрди: рдкреНрд░рдпреЛрдЬреНрдп рдИрдореЗрд▓ рд╡реИрд▓рд┐рдбреЗрдЯрд░ рдХреНрд▓рд╛рд╕ рдмрдирд╛рдирд╛
Production applications рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди logic рдХреЛ рдПрдХ рдкреБрди: рдкреНрд░рдпреЛрдЬреНрдп class рдореЗрдВ encapsulate рдХрд░рдиреЗ рд╕реЗ рд▓рд╛рднрд╛рдиреНрд╡рд┐рдд рд╣реЛрддреЗ рд╣реИрдВред рдпрд╣ рджреГрд╖реНрдЯрд┐рдХреЛрдг consistent error handling, automatic retries, рдФрд░ рдЖрдкрдХреЗ application рдХреЗ рд╢реЗрд╖ рднрд╛рдЧ рдХреЗ рд▓рд┐рдП рдЙрдкрднреЛрдЧ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдПрдХ рд╕реНрд╡рдЪреНрдЫ interface рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИред
рдХреНрд▓рд╛рд╕ рдЖрд░реНрдХрд┐рдЯреЗрдХреНрдЪрд░
EmailValidator class HTTP рд╡рд┐рд╡рд░рдгреЛрдВ рдХреЛ abstract рдХрд░рддреА рд╣реИ рдФрд░ рд╕рд╛рдорд╛рдиреНрдп рд╕рддреНрдпрд╛рдкрди рдкрд░рд┐рджреГрд╢реНрдпреЛрдВ рдХреЗ рд▓рд┐рдП methods рдкреНрд░рджрд╛рди рдХрд░рддреА рд╣реИред рдпрд╣ API authentication, request formatting, рдФрд░ response parsing рдХреЛ рд╕рдВрднрд╛рд▓рддреА рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдЖрдкрдХрд╛ application code API mechanics рдХреЗ рдмрдЬрд╛рдп business logic рдкрд░ рдзреНрдпрд╛рди рдХреЗрдВрджреНрд░рд┐рдд рдХрд░ рд╕рдХрддрд╛ рд╣реИред
// EmailValidator.js
import 'dotenv/config';
class EmailValidator {
constructor(apiKey = process.env.BILLIONVERIFY_API_KEY) {
this.apiKey = apiKey;
this.baseUrl = 'https://api.billionverify.com/v1';
this.maxRetries = 3;
this.retryDelay = 1000;
}
async verify(email) {
let lastError;
for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
try {
const response = await fetch(`${this.baseUrl}/verify`, {
method: 'POST',
headers: {
'Authorization': `Bearer ${this.apiKey}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ email })
});
if (response.status === 429) {
// Rate limited - wait and retry
await this.sleep(this.retryDelay * attempt);
continue;
}
if (!response.ok) {
throw new Error(`API error: ${response.status}`);
}
return await response.json();
} catch (error) {
lastError = error;
if (attempt < this.maxRetries) {
await this.sleep(this.retryDelay * attempt);
}
}
}
throw lastError;
}
async isValid(email) {
const result = await this.verify(email);
return result.is_valid && result.is_deliverable;
}
async isHighRisk(email) {
const result = await this.verify(email);
return result.risk_score > 70 || result.is_disposable;
}
sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
}
export default EmailValidator;
рд╕реНрд╡рдЪрд╛рд▓рд┐рдд рд░рд┐рдЯреНрд░рд╛рдИ рд▓реЙрдЬрд┐рдХ
рдпрд╣ class failed requests рдХреЗ рд▓рд┐рдП exponential backoff рдХреЛ рд▓рд╛рдЧреВ рдХрд░рддреА рд╣реИ, рдЬреЛ production reliability рдХреЗ рд▓рд┐рдП рдЖрд╡рд╢реНрдпрдХ рд╣реИред рдЬрдм рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рд╕реЗрд╡рд╛ rate limit error рд▓реМрдЯрд╛рддреА рд╣реИ рдпрд╛ рдЕрд╕реНрдерд╛рдпреА рд╕рдорд╕реНрдпрд╛рдУрдВ рдХрд╛ рдЕрдиреБрднрд╡ рдХрд░рддреА рд╣реИ, рддреЛ class рд╕реНрд╡рдЪрд╛рд▓рд┐рдд рд░реВрдк рд╕реЗ attempts рдХреЗ рдмреАрдЪ рдмрдврд╝рддреА рджреЗрд░реА рдХреЗ рд╕рд╛рде retry рдХрд░рддреА рд╣реИред
Express.js рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдХреЗ рд╕рд╛рде рдПрдХреАрдХрд░рдг
рдЕрдзрд┐рдХрд╛рдВрд╢ Node.js рд╡реЗрдм рдПрдкреНрд▓рд┐рдХреЗрд╢рди Express.js рдпрд╛ рд╕рдорд╛рди frameworks рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реИрдВред рдЕрдкрдиреЗ Express routes рдореЗрдВ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдХреЛ рдПрдХреАрдХреГрдд рдХрд░рдирд╛ form submissions рдХреЗ рджреМрд░рд╛рди real-time validation рдХреЛ рд╕рдХреНрд╖рдо рдмрдирд╛рддрд╛ рд╣реИред рдпреВрдЬрд╝рд░реНрд╕ рдХреЛ invalid email addresses рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рддрддреНрдХрд╛рд▓ feedback рдорд┐рд▓рддрд╛ рд╣реИ, рдЬреЛ рдЖрдкрдХреА email list quality рдХреА рд╕реБрд░рдХреНрд╖рд╛ рдХрд░рддреЗ рд╣реБрдП рдкрдВрдЬреАрдХрд░рдг рдЕрдиреБрднрд╡ рдореЗрдВ рд╕реБрдзрд╛рд░ рдХрд░рддрд╛ рд╣реИред
рд╡реЗрд░рд┐рдлрд┐рдХреЗрд╢рди рдорд┐рдбрд▓рд╡реЗрдпрд░ рдмрдирд╛рдирд╛
рдПрдХ middleware function рдмрдирд╛рдПрдВ рдЬреЛ рдЖрдкрдХреЗ route handlers рддрдХ рдкрд╣реБрдВрдЪрдиреЗ рд╕реЗ рдкрд╣рд▓реЗ рдИрдореЗрд▓ рдкрддреЛрдВ рдХреЛ validate рдХрд░рддрд╛ рд╣реИред рдпрд╣ рджреГрд╖реНрдЯрд┐рдХреЛрдг рд╕рддреНрдпрд╛рдкрди logic рдХреЛ business logic рд╕реЗ рдЕрд▓рдЧ рдХрд░рддрд╛ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдЖрдкрдХрд╛ code рдЕрдзрд┐рдХ maintainable рдФрд░ testable рдмрдирддрд╛ рд╣реИред
// server.js
import express from 'express';
import EmailValidator from './EmailValidator.js';
const app = express();
const validator = new EmailValidator();
app.use(express.json());
// Middleware for email verification
const verifyEmailMiddleware = async (req, res, next) => {
const { email } = req.body;
if (!email) {
return res.status(400).json({ error: 'Email is required' });
}
try {
const result = await validator.verify(email);
if (!result.is_valid) {
return res.status(400).json({
error: 'Invalid email address',
details: result
});
}
if (result.is_disposable) {
return res.status(400).json({
error: 'Disposable email addresses are not allowed'
});
}
// Attach verification result for downstream use
req.emailVerification = result;
next();
} catch (error) {
console.error('Email verification failed:', error);
// Allow request to proceed but flag as unverified
req.emailVerification = { verified: false, error: error.message };
next();
}
};
// Registration endpoint with email verification
app.post('/api/register', verifyEmailMiddleware, async (req, res) => {
const { email, name, password } = req.body;
// Email is already verified by middleware
// Proceed with registration logic
res.json({
success: true,
message: 'Registration successful',
emailVerification: req.emailVerification
});
});
app.listen(3000, () => {
console.log('Server running on port 3000');
});
рд╡реЗрд░рд┐рдлрд┐рдХреЗрд╢рди рдкрд░рд┐рдгрд╛рдореЛрдВ рдХреЛ рд╕рдВрднрд╛рд▓рдирд╛
Middleware рджреГрд╖реНрдЯрд┐рдХреЛрдг flexibility рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИ рдХрд┐ рдЖрдк рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдХреЛ рдХрд┐рддрдиреА рд╕рдЦреНрддреА рд╕реЗ рд▓рд╛рдЧреВ рдХрд░рддреЗ рд╣реИрдВред рдХреБрдЫ applications рд╕рднреА unverified emails рдХреЛ рдЕрд╕реНрд╡реАрдХрд╛рд░ рдХрд░рдирд╛ рдЪреБрди рд╕рдХрддреЗ рд╣реИрдВ, рдЬрдмрдХрд┐ рдЕрдиреНрдп рдЙрдиреНрд╣реЗрдВ manual review рдХреЗ рд▓рд┐рдП warning flag рдХреЗ рд╕рд╛рде рд╕реНрд╡реАрдХрд╛рд░ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред Request object рд╕реЗ рдЬреБрдбрд╝реЗ рдИрдореЗрд▓ рд╡реИрд▓рд┐рдбреЗрд╢рди рдкрд░рд┐рдгрд╛рдо downstream handlers рдХреЛ рд╕реВрдХреНрд╖реНрдо рдирд┐рд░реНрдгрдп рд▓реЗрдиреЗ рдореЗрдВ рд╕рдХреНрд╖рдо рдмрдирд╛рддреЗ рд╣реИрдВред
рд▓рд┐рд╕реНрдЯ рдХреНрд▓реАрдирд┐рдВрдЧ рдХреЗ рд▓рд┐рдП рдмреИрдЪ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди
рдЬрдмрдХрд┐ real-time verification рд╡реНрдпрдХреНрддрд┐рдЧрдд рдкрддреЛрдВ рдХреЛ рд╕рдВрднрд╛рд▓рддрд╛ рд╣реИ, рдХрдИ applications рдХреЛ рдмрдбрд╝реА email lists рдХреЛ verify рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИред Marketing teams рдирд┐рдпрдорд┐рдд рд░реВрдк рд╕реЗ рдЕрдкрдиреА subscriber lists рдХреЛ рд╕рд╛рдл рдХрд░рддреА рд╣реИрдВ, рдФрд░ CRM systems рд╕рдордп-рд╕рдордп рдкрд░ stored contacts рдХреЛ validate рдХрд░рддреЗ рд╣реИрдВред Batch verification endpoint рдХрдИ emails рдХреЛ рдХреБрд╢рд▓рддрд╛ рд╕реЗ process рдХрд░рддрд╛ рд╣реИ, API calls рдХреЛ рдХрдо рдХрд░рддрд╛ рд╣реИ рдФрд░ throughput рдореЗрдВ рд╕реБрдзрд╛рд░ рдХрд░рддрд╛ рд╣реИред
рдмреИрдЪ рдЬреЙрдмреНрд╕ рд╕рдмрдорд┐рдЯ рдХрд░рдирд╛
Batch operations рдХреЛ single verifications рд╕реЗ рдЕрд▓рдЧ handling рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИред рдЖрдкрдХреЛ job submission, status polling, рдФрд░ result retrieval рдХреЛ рдЕрд▓рдЧ operations рдХреЗ рд░реВрдк рдореЗрдВ manage рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрдЧреАред рдпрд╣ asynchronous pattern рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рд╕реЗрд╡рд╛ рдХреЛ timeout рдХреЗ рдмрд┐рдирд╛ рдмрдбрд╝реА lists рдХреЛ process рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИред
// batch-verify.js
import EmailValidator from './EmailValidator.js';
class BatchEmailValidator extends EmailValidator {
async submitBatch(emails) {
const response = await fetch(`${this.baseUrl}/verify/batch`, {
method: 'POST',
headers: {
'Authorization': `Bearer ${this.apiKey}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ emails })
});
if (!response.ok) {
throw new Error(`Batch submission failed: ${response.status}`);
}
return response.json();
}
async getBatchStatus(jobId) {
const response = await fetch(`${this.baseUrl}/verify/batch/${jobId}`, {
headers: {
'Authorization': `Bearer ${this.apiKey}`
}
});
if (!response.ok) {
throw new Error(`Status check failed: ${response.status}`);
}
return response.json();
}
async verifyBatch(emails, options = {}) {
const {
pollInterval = 5000,
maxWaitTime = 300000,
onProgress = () => {}
} = options;
// Submit the batch job
const { job_id } = await this.submitBatch(emails);
const startTime = Date.now();
// Poll for completion
while (Date.now() - startTime < maxWaitTime) {
const status = await this.getBatchStatus(job_id);
onProgress({
processed: status.processed,
total: status.total,
percentage: Math.round((status.processed / status.total) * 100)
});
if (status.status === 'completed') {
return status.results;
}
if (status.status === 'failed') {
throw new Error(`Batch job failed: ${status.error}`);
}
await this.sleep(pollInterval);
}
throw new Error('Batch verification timed out');
}
}
// Usage example
const batchValidator = new BatchEmailValidator();
const emails = [
'user1@example.com',
'user2@company.org',
'invalid@fake.domain',
// ... more emails
];
const results = await batchValidator.verifyBatch(emails, {
onProgress: (progress) => {
console.log(`Progress: ${progress.percentage}%`);
}
});
// Process results
const validEmails = results.filter(r => r.is_valid);
const invalidEmails = results.filter(r => !r.is_valid);
console.log(`Valid: ${validEmails.length}, Invalid: ${invalidEmails.length}`);
рдкрд░рд┐рдгрд╛рдореЛрдВ рдХреЗ рд▓рд┐рдП рдкреЛрд▓рд┐рдВрдЧ
Batch verification implementation рдореЗрдВ рдПрдХ progress callback рд╢рд╛рдорд┐рд▓ рд╣реИ, рдЬреЛ рдЖрдкрдХреЗ application рдХреЛ рдпреВрдЬрд╝рд░реНрд╕ рдХреЛ рд╕рддреНрдпрд╛рдкрди progress display рдХрд░рдиреЗ рдпрд╛ monitoring рдХреЗ рд▓рд┐рдП log рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИред рдпрд╣ рд╡рд┐рд╢реЗрд╖ рд░реВрдк рд╕реЗ рдЙрдкрдпреЛрдЧреА рд╣реИ рдЬрдм рд╣рдЬрд╛рд░реЛрдВ рдИрдореЗрд▓ рдкрддреЛрдВ рд╡рд╛рд▓реА lists рдХреЛ process рдХрд░рддреЗ рд╣реИрдВ рдЬрд┐рдиреНрд╣реЗрдВ рдкреВрд░рд╛ рд╣реЛрдиреЗ рдореЗрдВ рдХрдИ рдорд┐рдирдЯ рд▓рдЧ рд╕рдХрддреЗ рд╣реИрдВред
рдПрд░рд░ рд╣реИрдВрдбрд▓рд┐рдВрдЧ рдФрд░ рд░реЗрдЬрд┐рд▓рд┐рдПрдВрд╕
Production рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдПрдХреАрдХрд░рдг рдХреЛ errors рдХреЛ gracefully handle рдХрд░рдирд╛ рдЪрд╛рд╣рд┐рдПред Network issues, API rate limits, рдФрд░ service unavailability distributed systems рдореЗрдВ рдЕрдкрд░рд┐рд╣рд╛рд░реНрдп рд╣реИрдВред рдЙрдЪрд┐рдд error handling рдХреЛ рд▓рд╛рдЧреВ рдХрд░рдирд╛ рд╕реБрдирд┐рд╢реНрдЪрд┐рдд рдХрд░рддрд╛ рд╣реИ рдХрд┐ рдЖрдкрдХрд╛ application рддрдм рднреА functional рд░рд╣рддрд╛ рд╣реИ рдЬрдм рд╕рддреНрдпрд╛рдкрди рд╕реЗрд╡рд╛ рд╕рдорд╕реНрдпрд╛рдУрдВ рдХрд╛ рдЕрдиреБрднрд╡ рдХрд░рддреА рд╣реИред
рдХрд╕реНрдЯрдо рдПрд░рд░ рдХреНрд▓рд╛рд╕реЗрд╕
рдПрдХ рд╡реНрдпрд╛рдкрдХ error handling strategy рдмрдирд╛рдПрдВ рдЬреЛ рд╡рд┐рднрд┐рдиреНрди error types рдХреЗ рдмреАрдЪ рдЕрдВрддрд░ рдХрд░рддреА рд╣реИред Rate limits рдЬреИрд╕реА transient errors retry attempts рдХреЗ рдпреЛрдЧреНрдп рд╣реИрдВ, рдЬрдмрдХрд┐ invalid API keys рдЬреИрд╕реА permanent errors рдХреЛ рддрддреНрдХрд╛рд▓ рдзреНрдпрд╛рди рдФрд░ alerting рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИред
// errors.js
class EmailVerificationError extends Error {
constructor(message, code, retryable = false) {
super(message);
this.name = 'EmailVerificationError';
this.code = code;
this.retryable = retryable;
}
}
class RateLimitError extends EmailVerificationError {
constructor(retryAfter) {
super('Rate limit exceeded', 'RATE_LIMITED', true);
this.retryAfter = retryAfter;
}
}
class AuthenticationError extends EmailVerificationError {
constructor() {
super('Invalid API key', 'AUTH_FAILED', false);
}
}
// Enhanced validator with error handling
class RobustEmailValidator extends EmailValidator {
async verify(email) {
try {
const response = await fetch(`${this.baseUrl}/verify`, {
method: 'POST',
headers: {
'Authorization': `Bearer ${this.apiKey}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ email })
});
if (response.status === 401) {
throw new AuthenticationError();
}
if (response.status === 429) {
const retryAfter = response.headers.get('Retry-After') || 60;
throw new RateLimitError(parseInt(retryAfter));
}
if (response.status >= 500) {
throw new EmailVerificationError(
'Service temporarily unavailable',
'SERVICE_ERROR',
true
);
}
if (!response.ok) {
const error = await response.json();
throw new EmailVerificationError(
error.message || 'Verification failed',
'API_ERROR',
false
);
}
return response.json();
} catch (error) {
if (error instanceof EmailVerificationError) {
throw error;
}
// Network or parsing error
throw new EmailVerificationError(
error.message,
'NETWORK_ERROR',
true
);
}
}
}
export { EmailVerificationError, RateLimitError, AuthenticationError, RobustEmailValidator };
рдЧреНрд░реЗрд╕рдлреБрд▓ рдбрд┐рдЧреНрд░реЗрдбреЗрд╢рди рд▓рд╛рдЧреВ рдХрд░рдирд╛
рдЖрдкрдХрд╛ application code рдлрд┐рд░ рд╡рд┐рднрд┐рдиреНрди error types рдХреЛ рдЙрдЪрд┐рдд рд░реВрдк рд╕реЗ handle рдХрд░ рд╕рдХрддрд╛ рд╣реИ, рдпреВрдЬрд╝рд░реНрд╕ рдХреЛ meaningful feedback рдкреНрд░рджрд╛рди рдХрд░ рд╕рдХрддрд╛ рд╣реИ рдФрд░ operations teams рдХреЗ рд▓рд┐рдП рдЙрдЪрд┐рдд alerts trigger рдХрд░ рд╕рдХрддрд╛ рд╣реИред
рдкреНрд░рджрд░реНрд╢рди рдХреЗ рд▓рд┐рдП рдХреИрд╢рд┐рдВрдЧ рд▓рд╛рдЧреВ рдХрд░рдирд╛
рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди API calls рдХреА рдПрдХ cost рд╣реЛрддреА рд╣реИ, рдкреИрд╕реЗ рдФрд░ latency рджреЛрдиреЛрдВ рдХреЗ рд╕рдВрджрд░реНрдн рдореЗрдВред рдПрдХ caching layer рдХреЛ рд▓рд╛рдЧреВ рдХрд░рдирд╛ рд╕рдорд╛рди рдИрдореЗрд▓ рдкрддреЛрдВ рдХреЗ рд▓рд┐рдП redundant verifications рдХреЛ рдХрдо рдХрд░рддрд╛ рд╣реИ рдЬрдмрдХрд┐ response times рдореЗрдВ рд╕реБрдзрд╛рд░ рдХрд░рддрд╛ рд╣реИред рдПрдХ рдЕрдЪреНрдЫреА рддрд░рд╣ рд╕реЗ designed cache email validity рдХреА dynamic рдкреНрд░рдХреГрддрд┐ рдХрд╛ рд╕рдореНрдорд╛рди рдХрд░рддрд╛ рд╣реИ рдЬрдмрдХрд┐ meaningful performance benefits рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИред
рдЗрди-рдореЗрдореЛрд░реА рдХреИрд╢ рд░рдгрдиреАрддрд┐
рдЕрдкрдиреЗ use case рдХреЗ рдЖрдзрд╛рд░ рдкрд░ рдПрдХ рдЙрдЪрд┐рдд cache duration рдЪреБрдиреЗрдВред рдИрдореЗрд▓ validity рдмрджрд▓ рд╕рдХрддреА рд╣реИтАФmailboxes рд╣рдЯрд╛рдП рдЬрд╛рддреЗ рд╣реИрдВ, domains expire рд╣реЛ рдЬрд╛рддреЗ рд╣реИрдВ, catch-all configurations рдмрджрд▓рддреЗ рд╣реИрдВред рдЕрдзрд┐рдХрд╛рдВрд╢ applications рдХреЗ рд▓рд┐рдП 24 рдШрдВрдЯреЗ рдХрд╛ cache duration performance рдХреЗ рд╕рд╛рде accuracy рдХреЛ рд╕рдВрддреБрд▓рд┐рдд рдХрд░рддрд╛ рд╣реИред
// cached-validator.js
class CachedEmailValidator extends EmailValidator {
constructor(apiKey, cacheOptions = {}) {
super(apiKey);
this.cache = new Map();
this.cacheTTL = cacheOptions.ttl || 24 * 60 * 60 * 1000; // 24 hours
this.maxCacheSize = cacheOptions.maxSize || 10000;
}
getCacheKey(email) {
return email.toLowerCase().trim();
}
getCached(email) {
const key = this.getCacheKey(email);
const cached = this.cache.get(key);
if (!cached) return null;
if (Date.now() > cached.expiresAt) {
this.cache.delete(key);
return null;
}
return cached.result;
}
setCache(email, result) {
// Implement LRU eviction if cache is full
if (this.cache.size >= this.maxCacheSize) {
const oldestKey = this.cache.keys().next().value;
this.cache.delete(oldestKey);
}
const key = this.getCacheKey(email);
this.cache.set(key, {
result,
expiresAt: Date.now() + this.cacheTTL
});
}
async verify(email) {
// Check cache first
const cached = this.getCached(email);
if (cached) {
return { ...cached, fromCache: true };
}
// Perform verification
const result = await super.verify(email);
// Cache successful results
if (result && !result.error) {
this.setCache(email, result);
}
return { ...result, fromCache: false };
}
clearCache() {
this.cache.clear();
}
getCacheStats() {
return {
size: this.cache.size,
maxSize: this.maxCacheSize
};
}
}
export default CachedEmailValidator;
рдХреИрд╢ рдЗрдирд╡реИрд▓рд┐рдбреЗрд╢рди
High volumes рдХреЛ handle рдХрд░рдиреЗ рд╡рд╛рд▓реЗ production applications рдХреЗ рд▓рд┐рдП, in-memory cache рдХреЗ рдмрдЬрд╛рдп Redis рдпрд╛ Memcached рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдиреЗ рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВред рдпреЗ external cache stores application restarts рдХреЗ рдмреАрдЪ persist рдХрд░рддреЗ рд╣реИрдВ рдФрд░ clustered deployment рдореЗрдВ рдХрдИ application instances рдХреЗ рдмреАрдЪ рд╕рд╛рдЭрд╛ рдХрд┐рдП рдЬрд╛ рд╕рдХрддреЗ рд╣реИрдВред
рдЕрдкрдиреЗ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдПрдХреАрдХрд░рдг рдХрд╛ рдкрд░реАрдХреНрд╖рдг
рд╡реНрдпрд╛рдкрдХ рдкрд░реАрдХреНрд╖рдг рд╕реБрдирд┐рд╢реНрдЪрд┐рдд рдХрд░рддрд╛ рд╣реИ рдХрд┐ рдЖрдкрдХрд╛ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдПрдХреАрдХрд░рдг рд╕рднреА рдкрд░рд┐рджреГрд╢реНрдпреЛрдВ рдореЗрдВ рд╕рд╣реА рдврдВрдЧ рд╕реЗ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИред Unit tests рд╡реНрдпрдХреНрддрд┐рдЧрдд components рдХреЛ verify рдХрд░рддреЗ рд╣реИрдВ, рдЬрдмрдХрд┐ integration tests рдЙрдЪрд┐рдд API communication рдХреА рдкреБрд╖реНрдЯрд┐ рдХрд░рддреЗ рд╣реИрдВред рд╡рд╛рд╕реНрддрд╡рд┐рдХ API calls рдХрд░рдиреЗ рд╕реЗ рдмрдЪрдиреЗ рдХреЗ рд▓рд┐рдП unit tests рдХреЗ рджреМрд░рд╛рди HTTP layer рдХреЛ mock рдХрд░реЗрдВред
рдореЙрдХреНрд╕ рдХреЗ рд╕рд╛рде рдпреВрдирд┐рдЯ рдЯреЗрд╕реНрдЯрд┐рдВрдЧ
// validator.test.js
import { jest } from '@jest/globals';
import EmailValidator from './EmailValidator.js';
describe('EmailValidator', () => {
let validator;
beforeEach(() => {
validator = new EmailValidator('test-api-key');
global.fetch = jest.fn();
});
test('returns valid result for valid email', async () => {
fetch.mockResolvedValueOnce({
ok: true,
json: () => Promise.resolve({
is_valid: true,
is_deliverable: true,
is_disposable: false,
risk_score: 10
})
});
const result = await validator.verify('valid@example.com');
expect(result.is_valid).toBe(true);
expect(result.is_deliverable).toBe(true);
});
test('handles rate limiting with retry', async () => {
fetch
.mockResolvedValueOnce({ ok: false, status: 429 })
.mockResolvedValueOnce({
ok: true,
json: () => Promise.resolve({ is_valid: true })
});
const result = await validator.verify('test@example.com');
expect(fetch).toHaveBeenCalledTimes(2);
expect(result.is_valid).toBe(true);
});
test('throws after max retries exceeded', async () => {
fetch.mockResolvedValue({ ok: false, status: 500 });
await expect(validator.verify('test@example.com'))
.rejects.toThrow('API error: 500');
});
});
рдПрдЬ рдХреЗрд╕реЗрд╕ рдХрд╛ рдкрд░реАрдХреНрд╖рдг
Network failures, malformed responses, рдФрд░ рдЕрд╕рд╛рдорд╛рдиреНрдп email formats рдЬреИрд╕реЗ edge cases рдХреЗ рд▓рд┐рдП tests рд╢рд╛рдорд┐рд▓ рдХрд░реЗрдВред Email checker рдХреЛ рдЖрдкрдХреЗ application рдХреЛ crash рдХрд┐рдП рдмрд┐рдирд╛ рд╕рднреА рдкрд░рд┐рджреГрд╢реНрдпреЛрдВ рдХреЛ gracefully handle рдХрд░рдирд╛ рдЪрд╛рд╣рд┐рдПред
рдореЙрдирд┐рдЯрд░рд┐рдВрдЧ рдФрд░ рд▓реЙрдЧрд┐рдВрдЧ рдмреЗрд╕реНрдЯ рдкреНрд░реИрдХреНрдЯрд┐рд╕реЗрд╕
Production рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдПрдХреАрдХрд░рдг рдХреЛ performance track рдХрд░рдиреЗ, issues identify рдХрд░рдиреЗ, рдФрд░ costs optimize рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП monitoring рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИред Structured logging рд▓рд╛рдЧреВ рдХрд░реЗрдВ рдЬреЛ рд╕рддреНрдпрд╛рдкрди outcomes, response times, рдФрд░ error rates рдХреЛ capture рдХрд░рддреА рд╣реИред
рд╕реНрдЯреНрд░рдХреНрдЪрд░реНрдб рд▓реЙрдЧрд┐рдВрдЧ
// monitored-validator.js
class MonitoredEmailValidator extends EmailValidator {
constructor(apiKey, logger = console) {
super(apiKey);
this.logger = logger;
this.metrics = {
totalRequests: 0,
successfulVerifications: 0,
failedVerifications: 0,
cacheHits: 0,
totalLatency: 0
};
}
async verify(email) {
const startTime = Date.now();
this.metrics.totalRequests++;
try {
const result = await super.verify(email);
const latency = Date.now() - startTime;
this.metrics.successfulVerifications++;
this.metrics.totalLatency += latency;
this.logger.info({
event: 'email_verification',
email: this.maskEmail(email),
is_valid: result.is_valid,
latency_ms: latency
});
return result;
} catch (error) {
this.metrics.failedVerifications++;
this.logger.error({
event: 'email_verification_error',
email: this.maskEmail(email),
error: error.message,
latency_ms: Date.now() - startTime
});
throw error;
}
}
maskEmail(email) {
const [local, domain] = email.split('@');
const maskedLocal = local.charAt(0) + '***' + local.slice(-1);
return `${maskedLocal}@${domain}`;
}
getMetrics() {
return {
...this.metrics,
averageLatency: this.metrics.totalRequests > 0
? Math.round(this.metrics.totalLatency / this.metrics.totalRequests)
: 0,
successRate: this.metrics.totalRequests > 0
? (this.metrics.successfulVerifications / this.metrics.totalRequests * 100).toFixed(2)
: 0
};
}
}
export default MonitoredEmailValidator;
рдореЗрдЯреНрд░рд┐рдХреНрд╕ рдЯреНрд░реИрдХрд┐рдВрдЧ
Elevated error rates рдпрд╛ рдЕрд╕рд╛рдорд╛рдиреНрдп patterns рдХреЗ рд▓рд┐рдП alerts рд╕реЗрдЯ рдХрд░реЗрдВ рдЬреЛ API issues рдпрд╛ abuse attempts рдХрд╛ рд╕рдВрдХреЗрдд рджреЗ рд╕рдХрддреЗ рд╣реИрдВред Monitoring dashboards рдЖрдкрдХреЛ рд╕рддреНрдпрд╛рдкрди patterns рдХреЛ рд╕рдордЭрдиреЗ рдФрд░ рд╕рдордп рдХреЗ рд╕рд╛рде рдЕрдкрдиреЗ implementation рдХреЛ optimize рдХрд░рдиреЗ рдореЗрдВ рдорджрдж рдХрд░рддреЗ рд╣реИрдВред
рд╕реБрд░рдХреНрд╖рд╛ рд╡рд┐рдЪрд╛рд░
рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдПрдХреАрдХрд░рдг рд╕рдВрднрд╛рд╡рд┐рдд рд░реВрдк рд╕реЗ рд╕рдВрд╡реЗрджрдирд╢реАрд▓ data рдХреЛ handle рдХрд░рддреЗ рд╣реИрдВ рдФрд░ рд╕рд╛рд╡рдзрд╛рдиреАрдкреВрд░реНрд╡рдХ рд╕реБрд░рдХреНрд╖рд╛ рд╡рд┐рдЪрд╛рд░ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИред рдЕрдкрдиреА API keys рдХреА рд╕реБрд░рдХреНрд╖рд╛ рдХрд░реЗрдВ, inputs рдХреЛ validate рдХрд░реЗрдВ, рдФрд░ abuse рдХреЛ рд░реЛрдХрдиреЗ рдХреЗ рд▓рд┐рдП рдЕрдкрдиреЗ рд╕реНрд╡рдпрдВ рдХреЗ endpoints рдкрд░ rate limiting рд▓рд╛рдЧреВ рдХрд░реЗрдВред
API рдХреНрд░реЗрдбреЗрдВрд╢рд┐рдпрд▓реНрд╕ рдХреА рд╕реБрд░рдХреНрд╖рд╛
рдХрднреА рднреА рдЕрдкрдиреА BillionVerify API key рдХреЛ client-side code рдореЗрдВ expose рди рдХрд░реЗрдВред рд╕рднреА рд╕рддреНрдпрд╛рдкрди requests рдЖрдкрдХреЗ backend server рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ route рд╣реЛрдиреА рдЪрд╛рд╣рд┐рдП, рдЬреЛ API credentials рдХреЛ рд╕реБрд░рдХреНрд╖рд┐рдд рд░реВрдк рд╕реЗ рд░рдЦрддрд╛ рд╣реИред рдпрд╣ malicious actors рдХреЛ рдЕрдкрдиреЗ рд╕реНрд╡рдпрдВ рдХреЗ рдЙрджреНрджреЗрд╢реНрдпреЛрдВ рдХреЗ рд▓рд┐рдП рдЖрдкрдХреЗ API quota рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдиреЗ рд╕реЗ рд░реЛрдХрддрд╛ рд╣реИред
рдЗрдирдкреБрдЯ рд╡реИрд▓рд┐рдбреЗрд╢рди рдФрд░ рд░реЗрдЯ рд▓рд┐рдорд┐рдЯрд┐рдВрдЧ
рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди API рдХреЛ emails рднреЗрдЬрдиреЗ рд╕реЗ рдкрд╣рд▓реЗ input validation рд▓рд╛рдЧреВ рдХрд░реЗрдВред рдЖрдкрдХреА рддрд░рдл рд╕реЗ basic format validation рдЕрдирд╛рд╡рд╢реНрдпрдХ API calls рдХреЛ рдХрдо рдХрд░рддрд╛ рд╣реИ рдФрд░ рд╕реНрдкрд╖реНрдЯ рд░реВрдк рд╕реЗ invalid inputs рдХреЗ рд▓рд┐рдП рддреЗрдЬрд╝ feedback рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИред
// secure-validator.js
class SecureEmailValidator extends EmailValidator {
constructor(apiKey, options = {}) {
super(apiKey);
this.rateLimiter = new Map();
this.maxRequestsPerMinute = options.maxRequestsPerMinute || 100;
}
validateEmailFormat(email) {
if (!email || typeof email !== 'string') {
throw new Error('Email must be a non-empty string');
}
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
if (!emailRegex.test(email)) {
throw new Error('Invalid email format');
}
if (email.length > 254) {
throw new Error('Email exceeds maximum length');
}
return email.toLowerCase().trim();
}
checkRateLimit(clientId) {
const now = Date.now();
const windowStart = now - 60000;
if (!this.rateLimiter.has(clientId)) {
this.rateLimiter.set(clientId, []);
}
const requests = this.rateLimiter.get(clientId);
const recentRequests = requests.filter(time => time > windowStart);
if (recentRequests.length >= this.maxRequestsPerMinute) {
throw new Error('Rate limit exceeded. Please try again later.');
}
recentRequests.push(now);
this.rateLimiter.set(clientId, recentRequests);
}
async verify(email, clientId = 'default') {
this.checkRateLimit(clientId);
const sanitizedEmail = this.validateEmailFormat(email);
return super.verify(sanitizedEmail);
}
}
export default SecureEmailValidator;
рдирд┐рд╖реНрдХрд░реНрд╖
Node.js applications рдореЗрдВ email verification рдХреЛ рд▓рд╛рдЧреВ рдХрд░рдирд╛ рдЙрдЪреНрдЪ-рдЧреБрдгрд╡рддреНрддрд╛ рд╡рд╛рд▓реА email lists рдмрдирд╛рдП рд░рдЦрдиреЗ рдФрд░ рдЖрдкрдХреА sender reputation рдХреА рд╕реБрд░рдХреНрд╖рд╛ рдХреЗ рд▓рд┐рдП рдиреАрдВрд╡ рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИред рдЗрд╕ tutorial рдореЗрдВ рдХрд╡рд░ рдХреА рдЧрдИ рддрдХрдиреАрдХреЗрдВтАФbasic API integration рд╕реЗ рд▓реЗрдХрд░ production-ready patterns рддрдХ рдЬрд┐рдирдореЗрдВ caching, error handling, рдФрд░ monitoring рд╢рд╛рдорд┐рд▓ рд╣реИрдВтАФрдЖрдкрдХреЛ рдХрд┐рд╕реА рднреА Node.js application рдореЗрдВ robust рдИрдореЗрд▓ рд╡реИрд▓рд┐рдбреЗрд╢рди рдмрдирд╛рдиреЗ рдХреЗ рд▓рд┐рдП рддреИрдпрд╛рд░ рдХрд░рддреА рд╣реИрдВред
BillionVerify рдХрд╛ Node.js рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди API Node.js рдХреЗ рд╕рд╛рде seamlessly integrate рд╣реЛрддрд╛ рд╣реИ, real-time single email verification рдФрд░ batch processing capabilities рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИред Response data рдИрдореЗрд▓ рд╕реНрд╡реАрдХреГрддрд┐ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рд╕реВрдХреНрд╖реНрдо рдирд┐рд░реНрдгрдп рд▓реЗрдиреЗ рдореЗрдВ рд╕рдХреНрд╖рдо рдмрдирд╛рддрд╛ рд╣реИ, simple valid/invalid determinations рд╕реЗ рд▓реЗрдХрд░ sophisticated risk-based filtering рддрдХред
API patterns рдХреЛ рд╕рдордЭрдиреЗ рдХреЗ рд▓рд┐рдП basic implementation рд╕реЗ рд╢реБрд░реВ рдХрд░реЗрдВ, рдлрд┐рд░ рдЕрдкрдиреЗ application рдХреА requirements рдХреЗ рд╡рд┐рдХрд╕рд┐рдд рд╣реЛрдиреЗ рдХреЗ рд╕рд╛рде progressively caching, monitoring, рдФрд░ error handling рдЬреЛрдбрд╝реЗрдВред рдпрд╣рд╛рдВ рдкреНрд░рджрд░реНрд╢рд┐рдд рдИрдореЗрд▓ рдкрддрд╛ рд╕рддреНрдпрд╛рдкрд┐рдд рдХрд░реЗрдВ patterns startup MVPs рд╕реЗ рд▓реЗрдХрд░ рд▓рд╛рдЦреЛрдВ verifications рдХреЛ process рдХрд░рдиреЗ рд╡рд╛рд▓реЗ enterprise-grade applications рддрдХ scale рдХрд░рддреЗ рд╣реИрдВред рдЕрддрд┐рд░рд┐рдХреНрдд implementation patterns рдХреЗ рд▓рд┐рдП Developer Guide рджреЗрдЦреЗрдВред
рдЪрд╛рд╣реЗ рдЖрдк рдПрдХ рдпреВрдЬрд╝рд░ рдкрдВрдЬреАрдХрд░рдг рд╕рд┐рд╕реНрдЯрдо рдмрдирд╛ рд░рд╣реЗ рд╣реЛрдВ, marketing lists рдХреЛ рд╕рд╛рдл рдХрд░ рд░рд╣реЗ рд╣реЛрдВ, рдпрд╛ contact form submissions рдХреЛ validate рдХрд░ рд░рд╣реЗ рд╣реЛрдВ, рдЙрдЪрд┐рдд email verification рдЖрдкрдХреА email deliverability рдХреА рд╕реБрд░рдХреНрд╖рд╛ рдХрд░рддрд╛ рд╣реИ рдФрд░ рд╕реБрдирд┐рд╢реНрдЪрд┐рдд рдХрд░рддрд╛ рд╣реИ рдХрд┐ рдЖрдкрдХреЗ рд╕рдВрджреЗрд╢ рд╡рд╛рд╕реНрддрд╡рд┐рдХ рдкреНрд░рд╛рдкреНрддрдХрд░реНрддрд╛рдУрдВ рддрдХ рдкрд╣реБрдВрдЪреЗрдВред рдЖрдЬ рд╣реА BillionVerify account рдХреЗ рд▓рд┐рдП рд╕рд╛рдЗрди рдЕрдк рдХрд░рдХреЗ рдФрд░ рдЕрдкрдиреЗ Node.js application рдореЗрдВ рдИрдореЗрд▓ рд╕рддреНрдпрд╛рдкрди рдХреЛ рдПрдХреАрдХреГрдд рдХрд░рдХреЗ рдкрд╣рд▓рд╛ рдХрджрдо рдЙрдард╛рдПрдВред