!SharpAPI GitHub cover

Profanity Detection API for Node.js

🛡️ Detect profanities and inappropriate content with AI — powered by SharpAPI.


SharpAPI Profanity Detection analyzes text content for profanities, offensive language, and inappropriate content using AI. Essential for content moderation, community guidelines enforcement, and maintaining safe user environments.

---

📋 Table of Contents

1. Requirements
2. Installation
3. Usage
4. API Documentation
5. Response Format
6. Examples
7. License

---

Requirements

- Node.js >= 16.x
- npm or yarn

---

Installation

$3

``bash
npm install @sharpapi/sharpapi-node-detect-profanities
`

$3

Visit SharpAPI.com to get your API key.

---

Usage

`javascript
const { SharpApiDetectProfanitiesService } = require('@sharpapi/sharpapi-node-detect-profanities');

const apiKey = process.env.SHARP_API_KEY;
const service = new SharpApiDetectProfanitiesService(apiKey);

const userComment =
This is a sample comment that might contain inappropriate language.
Checking for profanities and offensive content.
;

async function checkContent() {
try {
const statusUrl = await service.detectProfanities(userComment);
console.log('Job submitted. Status URL:', statusUrl);

const result = await service.fetchResults(statusUrl);
const detection = result.getResultJson();

if (!detection.result.pass) {
console.log('⚠️ Profanity detected!');
console.log('Confidence:', detection.result.score + '%');
console.log('Reason:', detection.result.reason);
} else {
console.log('✅ Content is clean');
}
} catch (error) {
console.error('Error:', error.message);
}
}

checkContent();
`

---

API Documentation

$3

#### detectProfanities(text: string): Promise

Analyzes text content for profanities and inappropriate language.

Parameters:
- text (string, required): The text content to analyze

Returns:
- Promise: Status URL for polling the job result

---

Response Format

The API returns a detection result with confidence score:

`json
{
"data": {
"type": "api_job_result",
"id": "a8f2c1b5-9e4d-4a3b-8c7f-6d5e4f3a2b1c",
"attributes": {
"status": "success",
"type": "content_detect_profanities",
"result": {
"pass": false,
"score": 92,
"reason": "The text contains explicit profanity and offensive language that violates community guidelines."
}
}
}
}
`

Result Fields:
- pass (boolean): true if content is clean, false if profanities detected
- score (integer, 0-100): Confidence score of the detection
- 90-100: Very high confidence
- 75-89: High confidence
- 60-74: Moderate confidence
- Below 60: Low confidence (may need human review)
- reason (string): Explanation of why content was flagged or cleared

---

Examples

$3

`javascript
const { SharpApiDetectProfanitiesService } = require('@sharpapi/sharpapi-node-detect-profanities');

const service = new SharpApiDetectProfanitiesService(process.env.SHARP_API_KEY);

const content = 'This is a sample user comment to check for inappropriate content.';

service.detectProfanities(content)
.then(statusUrl => service.fetchResults(statusUrl))
.then(result => {
const detection = result.getResultJson().result;

if (detection.pass) {
console.log('✅ Content approved');
} else {
console.log(⚠️ Content flagged (${detection.score}% confidence));
console.log(Reason: ${detection.reason});
}
})
.catch(error => console.error('Detection failed:', error));
`

$3

`javascript
const service = new SharpApiDetectProfanitiesService(process.env.SHARP_API_KEY);

const userComments = [
{ id: 1, text: 'Great product! Really helpful.' },
{ id: 2, text: 'Terrible service, very disappointed.' },
{ id: 3, text: 'Amazing quality, highly recommend!' }
];

async function moderateComments(comments) {
const moderated = await Promise.all(
comments.map(async (comment) => {
try {
const statusUrl = await service.detectProfanities(comment.text);
const result = await service.fetchResults(statusUrl);
const detection = result.getResultJson().result;

return {
...comment,
approved: detection.pass,
confidence: detection.score,
reason: detection.reason,
requiresReview: !detection.pass && detection.score < 75
};
} catch (error) {
return {
...comment,
approved: false,
error: error.message,
requiresReview: true
};
}
})
);

return moderated;
}

const results = await moderateComments(userComments);

const approved = results.filter(r => r.approved).length;
const flagged = results.filter(r => !r.approved).length;
const needsReview = results.filter(r => r.requiresReview).length;

console.log(📊 Moderation Summary:);
console.log(Total: ${results.length});
console.log(✅ Approved: ${approved});
console.log(⚠️ Flagged: ${flagged});
console.log(👤 Needs Human Review: ${needsReview});
`

$3

`javascript
const service = new SharpApiDetectProfanitiesService(process.env.SHARP_API_KEY);

async function filterComment(comment, autoReject = true) {
const statusUrl = await service.detectProfanities(comment.text);
const result = await service.fetchResults(statusUrl);
const detection = result.getResultJson().result;

const action = {
commentId: comment.id,
userId: comment.userId,
text: comment.text,
pass: detection.pass,
confidence: detection.score,
reason: detection.reason,
status: '',
action: ''
};

if (detection.pass) {
action.status = 'approved';
action.action = 'publish';
} else if (detection.score >= 85 && autoReject) {
action.status = 'rejected';
action.action = 'auto_reject';
} else if (detection.score >= 60) {
action.status = 'flagged';
action.action = 'hold_for_review';
} else {
action.status = 'uncertain';
action.action = 'manual_review';
}

return action;
}

const newComment = {
id: 'CMT-12345',
userId: 'USER-789',
text: 'What a fantastic experience! Absolutely loved it!'
};

const moderation = await filterComment(newComment);

console.log(Comment Status: ${moderation.status});
console.log(Action: ${moderation.action});
console.log(Confidence: ${moderation.confidence}%);

if (moderation.action === 'publish') {
console.log('✅ Comment published successfully');
} else if (moderation.action === 'auto_reject') {
console.log('🚫 Comment automatically rejected');
console.log(Reason: ${moderation.reason});
} else {
console.log('⏸️ Comment held for manual review');
}
`

$3

`javascript
const service = new SharpApiDetectProfanitiesService(process.env.SHARP_API_KEY);

async function generateModerationReport(posts) {
const analyzed = await Promise.all(
posts.map(async (post) => {
const statusUrl = await service.detectProfanities(post.content);
const result = await service.fetchResults(statusUrl);
const detection = result.getResultJson().result;

return {
postId: post.id,
author: post.author,
timestamp: post.timestamp,
pass: detection.pass,
score: detection.score,
reason: detection.reason,
severity: detection.score >= 90 ? 'high' :
detection.score >= 75 ? 'medium' :
detection.score >= 60 ? 'low' : 'uncertain'
};
})
);

const report = {
totalPosts: posts.length,
clean: analyzed.filter(a => a.pass).length,
flagged: analyzed.filter(a => !a.pass).length,
highSeverity: analyzed.filter(a => a.severity === 'high').length,
mediumSeverity: analyzed.filter(a => a.severity === 'medium').length,
lowSeverity: analyzed.filter(a => a.severity === 'low').length,
needsReview: analyzed.filter(a => a.severity === 'uncertain').length,
posts: analyzed.filter(a => !a.pass).map(a => ({
postId: a.postId,
author: a.author,
severity: a.severity,
score: a.score,
reason: a.reason
}))
};

return report;
}

const forumPosts = [
{ id: 'POST-1', author: 'user123', content: 'Great discussion!', timestamp: new Date() },
{ id: 'POST-2', author: 'user456', content: 'Thanks for sharing!', timestamp: new Date() },
{ id: 'POST-3', author: 'user789', content: 'Very helpful post.', timestamp: new Date() }
];

const report = await generateModerationReport(forumPosts);

console.log('📋 Moderation Report:');
console.log(Total Posts: ${report.totalPosts});
console.log(Clean: ${report.clean});
console.log(Flagged: ${report.flagged});
console.log( - High Severity: ${report.highSeverity});
console.log( - Medium Severity: ${report.mediumSeverity});
console.log( - Low Severity: ${report.lowSeverity});
console.log( - Needs Review: ${report.needsReview});

if (report.posts.length > 0) {
console.log('\n🚨 Flagged Posts:');
report.posts.forEach(p => {
console.log( - ${p.postId} by ${p.author} (${p.severity} severity, ${p.score}%));
console.log( Reason: ${p.reason});
});
}
`

---

Use Cases

- Social Media Platforms: Moderate user comments and posts
- Community Forums: Enforce community guidelines automatically
- Gaming Platforms: Filter chat messages and usernames
- E-commerce: Screen product reviews and seller messages
- Educational Platforms: Maintain safe learning environments
- Dating Apps: Screen user profiles and messages
- Customer Support: Filter support tickets and feedback
- Live Chat: Real-time message filtering

---

Detection Capabilities

The AI analyzes content for:

- Explicit Profanity: Curse words and vulgar language
- Offensive Slurs: Discriminatory or hate speech
- Sexual Content: Inappropriate sexual references
- Harassment: Threatening or bullying language
- Toxic Behavior: Generally harmful or abusive content
- Masked Profanity: Attempts to bypass filters with symbols or misspellings

---

Integration Tips

$3

Recommended confidence score thresholds:

- ≥ 90%: Auto-reject/block (very high confidence)
- 75-89%: Flag for priority review (high confidence)
- 60-74%: Queue for review (moderate confidence)
- < 60%: Manual review required (low confidence)

$3

- Use batch processing for bulk moderation
- Cache results for repeated content checks
- Implement queue systems for high-volume scenarios
- Combine with other moderation tools for comprehensive coverage

---

API Endpoint

POST /content/detect_profanities`

For detailed API specifications, refer to:
- Main API Documentation
- SharpAPI.com

---

Related Packages

- @sharpapi/sharpapi-node-detect-spam - Spam detection
- @sharpapi/sharpapi-node-detect-phones - Phone number extraction
- @sharpapi/sharpapi-node-detect-emails - Email extraction
- @sharpapi/sharpapi-node-detect-urls - URL extraction
- @sharpapi/sharpapi-node-client - Full SharpAPI SDK

---

License

This project is licensed under the MIT License. See the LICENSE.md file for details.

---

Support

- Documentation: SharpAPI.com Documentation
- Issues: GitHub Issues
- Email: contact@sharpapi.com

---

Powered by SharpAPI - AI-Powered API Workflow Automation