https://github.com/devmehq/open-graph-extractor
Extract Open Graph and Metadata from html in node.js
https://github.com/devmehq/open-graph-extractor
extractor metadata-extractor opengraph opengraph-tags
Last synced: 5 months ago
JSON representation
Extract Open Graph and Metadata from html in node.js
- Host: GitHub
- URL: https://github.com/devmehq/open-graph-extractor
- Owner: devmehq
- License: mit
- Created: 2021-12-27T18:46:36.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2025-08-27T03:54:18.000Z (10 months ago)
- Last Synced: 2025-10-03T01:29:57.599Z (9 months ago)
- Topics: extractor, metadata-extractor, opengraph, opengraph-tags
- Language: HTML
- Homepage: https://dev.me/products/url-scrapper
- Size: 1.36 MB
- Stars: 9
- Watchers: 1
- Forks: 2
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE.md
Awesome Lists containing this project
README
# Open Graph Extractor 🚀
[](https://github.com/devmehq/open-graph-extractor/actions/workflows/ci.yml)
[](https://www.npmjs.com/package/@devmehq/open-graph-extractor)
[](https://www.npmjs.com/package/@devmehq/open-graph-extractor)
**Fast, lightweight, and comprehensive Open Graph extractor for Node.js with advanced features**
Extract Open Graph tags, Twitter Cards, structured data, and 60+ meta tag types with built-in caching, validation, and bulk processing. Optimized for performance and security.
## ✨ Why Choose This Library?
- 🚀 **Lightning Fast**: Built-in caching with tiny-lru and optimized parsing
- 🎯 **Production Ready**: Comprehensive error handling, validation, and security features
- 🏆 **Most Complete**: Extracts Open Graph, Twitter Cards, JSON-LD, Schema.org, and 60+ meta tags
- 📊 **Smart Analytics**: Built-in validation, social scoring, and performance metrics
- 🛡️ **Security First**: HTML sanitization, URL validation, and PII protection (Node.js only)
- 🔧 **Developer Friendly**: Full TypeScript support, modern async/await API
## 🌟 Key Features
### Core Extraction
- ✅ **60+ Meta Tags**: Open Graph, Twitter Cards, Dublin Core, App Links
- ✅ **JSON-LD Extraction**: Complete structured data parsing
- ✅ **Schema.org Support**: Microdata and RDFa extraction
- ✅ **Smart Fallbacks**: Intelligent content detection when tags are missing
### Advanced Features
- 🖼️ **Smart Media**: Automatic format detection and best image selection
- 📹 **Rich Metadata**: Video, audio, and responsive image support
- 💾 **Smart Caching**: Built-in memory cache with tiny-lru
- 🚀 **Bulk Processing**: Concurrent extraction for multiple URLs
### Quality & Analytics
- ✨ **Data Validation**: Comprehensive Open Graph and Twitter Card validation
- 📈 **Social Scoring**: 0-100 score for social media optimization
- 🎯 **SEO Insights**: Performance metrics and recommendations
- ⏱️ **Performance Tracking**: Detailed timing and statistics
### Security & Privacy
- 🛡️ **HTML Sanitization**: XSS protection using Cheerio (Node.js only)
- 🔐 **PII Protection**: Automatic detection and masking of sensitive data
- 🌐 **URL Security**: Domain filtering and validation
- 🚫 **Content Safety**: Malicious content detection
## 📦 Installation
```bash
# Using yarn (recommended)
yarn add @devmehq/open-graph-extractor
# Using npm
npm install @devmehq/open-graph-extractor
```
## 🚀 Quick Start
### Basic Usage (Synchronous)
```typescript
import axios from 'axios';
import { extractOpenGraph } from '@devmehq/open-graph-extractor';
// Fetch HTML and extract Open Graph data
const { data: html } = await axios.get('https://example.com');
const ogData = extractOpenGraph(html);
console.log(ogData);
// {
// ogTitle: 'Example Title',
// ogDescription: 'Example Description',
// ogImage: 'https://example.com/image.jpg',
// twitterCard: 'summary_large_image',
// favicon: 'https://example.com/favicon.ico'
// // ... 60+ more fields
// }
```
### Advanced Usage (Async with All Features)
```typescript
import { extractOpenGraphAsync } from '@devmehq/open-graph-extractor';
// Extract with validation, caching, and structured data
const result = await extractOpenGraphAsync(html, {
extractStructuredData: true,
validateData: true,
generateScore: true,
cache: {
enabled: true,
ttl: 3600, // 1 hour
storage: 'memory'
},
security: {
sanitizeHtml: true,
validateUrls: true
}
});
console.log(result);
// {
// data: { /* Complete Open Graph data */ },
// structuredData: { /* JSON-LD, Schema.org, etc */ },
// confidence: 95,
// errors: [],
// warnings: [],
// metrics: { /* Performance data */ }
// }
```
## 🎯 Advanced Features
### JSON-LD & Structured Data Extraction
```typescript
const result = await extractOpenGraphAsync(html, {
extractStructuredData: true
});
console.log(result.structuredData);
// {
// jsonLD: [...], // All JSON-LD scripts
// schemaOrg: {...}, // Schema.org microdata
// dublinCore: {...}, // Dublin Core metadata
// microdata: {...}, // Microdata
// rdfa: {...} // RDFa data
// }
```
### Bulk Processing
```typescript
import { extractOpenGraphBulk } from '@devmehq/open-graph-extractor';
const urls = ['url1', 'url2', 'url3'...];
const results = await extractOpenGraphBulk({
urls,
concurrency: 5,
rateLimit: {
requests: 100,
window: 60000 // 1 minute
},
onProgress: (completed, total, url) => {
console.log(`Processing ${completed}/${total}: ${url}`);
}
});
```
### Validation & Scoring
```typescript
import { validateOpenGraph, generateSocialScore } from '@devmehq/open-graph-extractor';
// Validate Open Graph data
const validation = validateOpenGraph(ogData);
console.log(validation);
// {
// valid: false,
// errors: [...],
// warnings: [...],
// score: 75,
// recommendations: [...]
// }
// Get social media score
const score = generateSocialScore(ogData);
console.log(score);
// {
// overall: 82,
// openGraph: { score: 90, ... },
// twitter: { score: 75, ... },
// recommendations: [...]
// }
```
### Security Features
```typescript
const result = await extractOpenGraphAsync(html, {
security: {
sanitizeHtml: true, // XSS protection using Cheerio
detectPII: true, // PII detection
maskPII: true, // Mask sensitive data
validateUrls: true, // URL validation
allowedDomains: ['example.com'],
blockedDomains: ['malicious.com']
}
});
```
### Caching
```typescript
// With built-in memory cache (tiny-lru)
const result = await extractOpenGraphAsync(html, {
cache: {
enabled: true,
ttl: 3600, // 1 hour
storage: 'memory',
maxSize: 1000
}
});
// With custom cache (Redis example)
import Redis from 'ioredis';
const redis = new Redis();
const result = await extractOpenGraphAsync(html, {
cache: {
enabled: true,
ttl: 3600,
storage: 'custom',
customStorage: {
async get(key) {
const value = await redis.get(key);
return value ? JSON.parse(value) : null;
},
async set(key, value, ttl) {
await redis.setex(key, ttl, JSON.stringify(value));
},
async delete(key) {
await redis.del(key);
},
async clear() {
await redis.flushdb();
},
async has(key) {
return (await redis.exists(key)) === 1;
}
}
}
});
```
### Enhanced Media Support
```typescript
const result = await extractOpenGraphAsync(html);
// Automatically detects and prioritizes best images
console.log(result.data.ogImage);
// {
// url: 'https://example.com/image.jpg',
// type: 'jpg',
// width: '1200',
// height: '630',
// alt: 'Description'
// }
// For multiple images, set allMedia: true
const allMediaResult = extractOpenGraph(html, { allMedia: true });
console.log(allMediaResult.ogImage);
// [
// { url: '...', width: '1200', height: '630', type: 'jpg' },
// { url: '...', width: '800', height: '600', type: 'png' }
// ]
```
## 📋 Complete API Reference
### Core Functions
#### `extractOpenGraph(html, options?)`
**Synchronous extraction** - Fast and lightweight for basic use cases.
```typescript
import { extractOpenGraph } from '@devmehq/open-graph-extractor';
const data = extractOpenGraph(html, {
customMetaTags: [
{ multiple: false, property: 'article:author', fieldName: 'author' }
],
allMedia: true, // Extract all images/videos
ogImageFallback: true, // Fallback to page images
onlyGetOpenGraphInfo: false // Include fallback content
});
```
#### `extractOpenGraphAsync(html, options?)`
**Asynchronous extraction** - Full feature set with advanced capabilities.
```typescript
import { extractOpenGraphAsync } from '@devmehq/open-graph-extractor';
const result = await extractOpenGraphAsync(html, {
// Core options
extractStructuredData: true, // JSON-LD, Schema.org, Microdata
validateData: true, // Data validation
generateScore: true, // SEO/social scoring
extractArticleContent: true, // Article text extraction
detectLanguage: true, // Language detection
normalizeUrls: true, // URL normalization
// Advanced features
cache: { enabled: true, ttl: 3600 },
security: { sanitizeHtml: true, validateUrls: true }
});
```
### Configuration Options
#### `IExtractOpenGraphOptions` (Sync)
| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `customMetaTags` | Array | `[]` | Custom meta tags to extract |
| `allMedia` | boolean | `false` | Extract all images/videos instead of just the first |
| `onlyGetOpenGraphInfo` | boolean | `false` | Skip fallback content extraction |
| `ogImageFallback` | boolean | `false` | Enable image fallback from page content |
#### `IExtractOpenGraphOptions` (Async) - Extends Sync Options
| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `extractStructuredData` | boolean | `false` | Extract JSON-LD, Schema.org, Microdata |
| `validateData` | boolean | `false` | Validate extracted Open Graph data |
| `generateScore` | boolean | `false` | Generate SEO/social media score (0-100) |
| `extractArticleContent` | boolean | `false` | Extract main article text content |
| `detectLanguage` | boolean | `false` | Detect content language and text direction |
| `normalizeUrls` | boolean | `false` | Normalize and clean all URLs |
| `cache` | ICacheOptions | `undefined` | Caching configuration |
| `security` | ISecurityOptions | `undefined` | Security and validation settings |
#### `ICacheOptions`
| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `enabled` | boolean | `false` | Enable caching |
| `ttl` | number | `3600` | Time-to-live in seconds |
| `storage` | string | `'memory'` | Storage type: 'memory', 'redis', 'custom' |
| `maxSize` | number | `1000` | Maximum cache entries (memory only) |
| `keyGenerator` | Function | - | Custom cache key generator |
| `customStorage` | ICacheStorage | - | Custom storage implementation |
#### `ISecurityOptions`
| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `sanitizeHtml` | boolean | `false` | Sanitize HTML content (XSS protection) |
| `detectPII` | boolean | `false` | Detect personally identifiable information |
| `maskPII` | boolean | `false` | Mask detected PII in results |
| `validateUrls` | boolean | `false` | Validate and filter URLs |
| `maxRedirects` | number | `5` | Maximum URL redirects to follow |
| `timeout` | number | `10000` | Request timeout in milliseconds |
| `allowedDomains` | string[] | `[]` | Allowed domains whitelist |
| `blockedDomains` | string[] | `[]` | Blocked domains blacklist |
### Return Types
#### `IOGResult` (Sync)
Basic extraction result with 60+ fields:
```typescript
{
ogTitle?: string;
ogDescription?: string;
ogImage?: string | string[] | IOgImage | IOgImage[];
ogUrl?: string;
ogType?: OGType;
twitterCard?: TwitterCardType;
favicon?: string;
// ... 50+ more fields including:
// Twitter Cards, App Links, Article metadata,
// Product info, Music data, Dublin Core, etc.
}
```
#### `IExtractionResult` (Async)
Enhanced result with validation and metrics:
```typescript
{
data: IOGResult; // Extracted Open Graph data
structuredData: { // Structured data extraction
jsonLD: any[];
schemaOrg: any;
microdata: any;
rdfa: any;
dublinCore: any;
};
errors: IError[]; // Validation errors
warnings: IWarning[]; // Validation warnings
confidence: number; // Confidence score (0-100)
confidenceLevel: 'high' | 'medium' | 'low';
fallbacksUsed: string[]; // Which fallbacks were used
metrics: IMetrics; // Performance metrics
validation?: IValidationResult; // Validation details (if enabled)
socialScore?: ISocialScore; // Social media scoring (if enabled)
}
```
### Utility Functions
#### `validateOpenGraph(data)`
Validates Open Graph data against specifications.
```typescript
import { validateOpenGraph } from '@devmehq/open-graph-extractor';
const validation = validateOpenGraph(ogData);
console.log(validation);
// {
// valid: boolean,
// errors: IError[],
// warnings: IWarning[],
// score: number,
// recommendations: string[]
// }
```
#### `generateSocialScore(data)`
Generates social media optimization score (0-100).
```typescript
import { generateSocialScore } from '@devmehq/open-graph-extractor';
const score = generateSocialScore(ogData);
console.log(score);
// {
// overall: number,
// openGraph: { score, present, missing, issues },
// twitter: { score, present, missing, issues },
// schema: { score, present, missing, issues },
// seo: { score, present, missing, issues },
// recommendations: string[]
// }
```
#### `extractOpenGraphBulk(options)`
Process multiple URLs concurrently with rate limiting.
```typescript
import { extractOpenGraphBulk } from '@devmehq/open-graph-extractor';
const results = await extractOpenGraphBulk({
urls: ['url1', 'url2', 'url3'],
concurrency: 5, // Process 5 URLs simultaneously
rateLimit: { // Rate limiting
requests: 100, // Max 100 requests
window: 60000 // Per 60 seconds
},
continueOnError: true, // Don't stop on individual failures
onProgress: (completed, total, url) => {
console.log(`Progress: ${completed}/${total} - ${url}`);
},
onError: (url, error) => {
console.error(`Failed to process ${url}:`, error);
}
});
console.log(results.summary);
// {
// total: number,
// successful: number,
// failed: number,
// totalDuration: number,
// averageDuration: number
// }
```
## 🎨 Custom Meta Tags
```typescript
// Extract custom meta tags
const result = extractOpenGraph(html, {
customMetaTags: [
{
multiple: false,
property: 'article:author',
fieldName: 'articleAuthor'
},
{
multiple: true,
property: 'article:tag',
fieldName: 'articleTags'
}
]
});
console.log(result.articleAuthor); // Custom field
console.log(result.articleTags); // Array of tags
```
## 🌟 **Complete Feature Guide**
### **Core Extraction Features**
#### **Meta Tag Extraction (60+ Types)**
- **Open Graph**: Complete og:* tag support with type validation
- **Twitter Cards**: All twitter:* tags including player and app cards
- **Dublin Core**: dc:* metadata extraction
- **App Links**: al:* tags for mobile app deep linking
- **Article Metadata**: Publishing dates, authors, sections, tags
- **Product Info**: Prices, availability, condition, retailer data
- **Music Metadata**: Albums, artists, songs, duration
- **Place/Location**: GPS coordinates and location data
```typescript
// Automatically extracts all supported meta types
const data = extractOpenGraph(html);
console.log(data.ogTitle, data.twitterCard, data.articleAuthor);
```
#### **Intelligent Fallbacks**
When meta tags are missing, the library intelligently falls back to:
- `` tags for ogTitle
- Meta descriptions for ogDescription
- Page images for ogImage
- Canonical URLs for ogUrl
- Page content analysis for missing data
```typescript
// Fallbacks work automatically
const data = extractOpenGraph(html, { ogImageFallback: true });
// Will find images even if og:image is missing
```
### **Advanced Extraction Features**
#### **Structured Data Extraction**
- **JSON-LD**: Parses all `` blocks
- **Schema.org**: Extracts microdata with itemscope/itemprop
- **RDFa**: Resource Description Framework attributes
- **Microdata**: HTML5 microdata extraction
```typescript
const result = await extractOpenGraphAsync(html, {
extractStructuredData: true
});
console.log(result.structuredData);
// {
// jsonLD: [{ "@type": "Article", "headline": "..." }],
// schemaOrg: { "Product": { "name": "...", "price": "..." }},
// microdata: { "Review": { "rating": "5" }},
// rdfa: { "Person": { "name": "John Doe" }}
// }
```
#### **Content Analysis**
- **Article Extraction**: Finds and extracts main article content
- **Reading Time**: Calculates estimated reading time
- **Word Count**: Counts words in extracted content
- **Language Detection**: Auto-detects content language and text direction
```typescript
const result = await extractOpenGraphAsync(html, {
extractArticleContent: true,
detectLanguage: true
});
console.log(result.data.articleContent); // Main article text
console.log(result.data.readingTime); // 5 (minutes)
console.log(result.data.language); // "en-US"
console.log(result.data.textDirection); // "ltr"
```
### **Data Quality Features**
#### **Comprehensive Validation**
- **Open Graph Validation**: Checks required fields and formats
- **Twitter Card Validation**: Ensures proper card types and content
- **URL Validation**: Verifies image and video URLs
- **Content Validation**: Checks for reasonable field lengths
```typescript
const result = await extractOpenGraphAsync(html, {
validateData: true
});
if (!result.validation.valid) {
console.log("Issues found:");
result.validation.errors.forEach(error => {
console.log(`- ${error.field}: ${error.message}`);
});
console.log("Recommendations:");
result.validation.recommendations.forEach(rec => {
console.log(`- ${rec}`);
});
}
```
#### **Social Media Scoring**
Generates SEO and social media optimization scores (0-100):
```typescript
const result = await extractOpenGraphAsync(html, {
generateScore: true
});
console.log(`Overall Score: ${result.socialScore.overall}/100`);
console.log(`Open Graph: ${result.socialScore.openGraph.score}/100`);
console.log(`Twitter: ${result.socialScore.twitter.score}/100`);
// Get actionable recommendations
result.socialScore.recommendations.forEach(rec => {
console.log(`💡 ${rec}`);
});
// 💡 Add og:image for better social sharing
// 💡 Include twitter:card for Twitter optimization
```
### **Performance Features**
#### **Smart Caching System**
- **Memory Cache**: Built-in LRU cache with tiny-lru
- **Redis Support**: Enterprise-ready Redis caching
- **Custom Storage**: Implement your own cache backend
- **TTL Control**: Configurable expiration times
```typescript
// Memory caching
const result = await extractOpenGraphAsync(html, {
cache: {
enabled: true,
ttl: 3600, // 1 hour
maxSize: 1000, // Max entries
storage: 'memory'
}
});
// Redis caching
const result = await extractOpenGraphAsync(html, {
cache: {
enabled: true,
ttl: 7200, // 2 hours
storage: 'redis' // Requires Redis setup
}
});
```
#### **Bulk Processing with Rate Limiting**
Process multiple URLs efficiently with concurrency control:
```typescript
const results = await extractOpenGraphBulk({
urls: siteUrls,
concurrency: 10, // 10 simultaneous requests
rateLimit: {
requests: 100, // Max 100 requests
window: 60000 // Per minute
},
onProgress: (done, total, url) => {
updateProgressBar(done / total);
}
});
console.log(`Processed ${results.summary.successful}/${results.summary.total} URLs`);
```
#### **Performance Monitoring**
Detailed metrics for optimization:
```typescript
const result = await extractOpenGraphAsync(html);
console.log("Performance Metrics:");
console.log(`- Total time: ${result.metrics.performance.totalTime}ms`);
console.log(`- HTML parsing: ${result.metrics.performance.htmlParseTime}ms`);
console.log(`- Meta extraction: ${result.metrics.performance.metaExtractionTime}ms`);
console.log(`- Found ${result.metrics.metaTagsFound} meta tags`);
console.log(`- Used fallbacks: ${result.fallbacksUsed.join(', ')}`);
```
### **Security Features**
#### **Content Sanitization**
- **XSS Protection**: Sanitizes HTML content using Cheerio
- **URL Validation**: Prevents SSRF attacks
- **Domain Control**: Allow/block specific domains
- **Content Filtering**: Remove malicious content
```typescript
const result = await extractOpenGraphAsync(html, {
security: {
sanitizeHtml: true, // Clean HTML content
validateUrls: true, // Verify all URLs
allowedDomains: [ // Only allow these domains
'example.com',
'cdn.example.com'
],
blockedDomains: [ // Block these domains
'malicious.com'
],
maxRedirects: 3, // Limit URL redirects
timeout: 5000 // 5 second timeout
}
});
```
#### **Privacy Protection**
- **PII Detection**: Automatically detects personal information
- **Data Masking**: Optional masking of sensitive content
- **Safe Extraction**: Removes potentially harmful data
```typescript
const result = await extractOpenGraphAsync(html, {
security: {
detectPII: true, // Detect emails, phones, addresses
maskPII: true // Mask detected PII in results
}
});
// PII will be masked in the output
// "Contact: j***@example.com" instead of "Contact: john@example.com"
```
### **Enhanced Media Support**
#### **Smart Image Processing**
- **Format Detection**: Supports JPG, PNG, GIF, WebP, AVIF, SVG
- **Size Optimization**: Automatically selects best image sizes
- **Responsive Images**: Handles srcset and multiple formats
- **Fallback Images**: Finds images when og:image is missing
```typescript
// Enhanced image extraction
const result = await extractOpenGraphAsync(html, {
allMedia: true // Extract all images, not just the first
});
console.log(result.data.ogImage);
// [
// { url: 'image1.jpg', width: 1200, height: 630, type: 'jpg' },
// { url: 'image2.png', width: 800, height: 600, type: 'png' }
// ]
```
#### **Video & Audio Metadata**
- **Video Information**: Duration, thumbnails, captions, chapters
- **Audio Metadata**: Track info, artists, albums, duration
- **Streaming Support**: Handles video players and streaming URLs
```typescript
const result = await extractOpenGraphAsync(videoPageHtml);
console.log(result.data.ogVideo);
// {
// url: 'video.mp4',
// duration: 300,
// thumbnails: [{ url: 'thumb.jpg', width: 1280, height: 720 }],
// captions: [{ language: 'en', url: 'captions.vtt' }]
// }
```
## 📈 Metrics & Monitoring
```typescript
const result = await extractOpenGraphAsync(html);
console.log(result.metrics);
// {
// extractionTime: 125, // ms
// htmlSize: 54321, // bytes
// metaTagsFound: 15,
// structuredDataFound: 3,
// imagesFound: 8,
// videosFound: 1,
// fallbacksUsed: ['title', 'description'],
// performance: {
// htmlParseTime: 20,
// metaExtractionTime: 10,
// structuredDataExtractionTime: 15,
// validationTime: 5,
// totalTime: 125
// }
// }
```
## 🧪 Testing
```bash
# Run tests
yarn test
# Run with coverage
yarn test --coverage
```
## 🔧 Development
```bash
# Install dependencies
yarn install
# Build
yarn build
# Lint and format with Biome
yarn lint
yarn format
# Type check
yarn typecheck
```
## 🤝 API / Cloud Service
We offer this as a managed Cloud API Service. Try it here: [URL Scraping & Metadata Service](https://dev.me/products/url-scrapper)
## 📖 TypeScript Support
The library is fully typed with comprehensive TypeScript definitions:
- `IOGResult` - Main result interface with 60+ fields
- `IExtractionResult` - Async extraction result with metrics
- `IExtractOpenGraphOptions` - Configuration options
- `IStructuredData` - JSON-LD and structured data types
- `IValidationResult` - Data validation results
- `ISocialScore` - Social media scoring details
- `IMetrics` - Performance tracking metrics
All types are exported for your use in TypeScript projects.
## 🌟 Why Choose This Library?
| Feature | This Library | Others |
|---------|-------------|---------|
| Open Graph | ✅ Complete (60+ fields) | ✅ Basic |
| Twitter Cards | ✅ Complete | ⚠️ Partial |
| JSON-LD | ✅ Full Extraction | ❌ No |
| Schema.org | ✅ Microdata/RDFa | ❌ No |
| Caching | ✅ Built-in (tiny-lru) | ❌ No |
| Bulk Processing | ✅ Concurrent | ❌ No |
| Validation | ✅ Comprehensive | ❌ No |
| Security | ✅ Node.js optimized | ❌ No |
| TypeScript | ✅ Full Types | ⚠️ Partial |
| Performance | ✅ Optimized | ⚠️ Variable |
| Maintenance | ✅ Active | ⚠️ Variable |
## 🛡️ Security
- **HTML Sanitization**: Uses Cheerio for safe HTML parsing (Node.js only)
- **PII Detection**: Automatic detection and masking of sensitive data
- **URL Validation**: Prevents SSRF attacks with domain filtering
- **Content Security**: Malicious content detection and filtering
## 📈 Performance
- **Fast Extraction**: Sub-100ms for average pages
- **Smart Caching**: Built-in tiny-lru cache reduces repeated processing
- **Concurrent Processing**: Configurable concurrency for bulk operations
- **Optimized Parsing**: Cheerio-based parsing for Node.js performance
## 🤝 Contributing
We welcome contributions! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
## 📄 License
[MIT](LICENSE.md)
## 🙏 Acknowledgments
Built with:
- [Cheerio](https://cheerio.js.org/) - Fast, flexible & lean implementation of jQuery for Node.js
- [tiny-lru](https://github.com/avoidwork/tiny-lru) - Tiny LRU cache for high-performance caching
- [Biome](https://biomejs.dev/) - Fast formatter and linter for JavaScript and TypeScript
---
**Made with ❤️ by [DEV.ME](https://dev.me)**
*Need help or custom features? [Contact us](https://dev.me/contact)*