Why Add Plagiarism Detection to Your Product?
Plagiarism detection solves critical problems for multiple product categories. For learning management systems (Canvas, Blackboard, Schoology), adding plagiarism detection increases institutional value. Teachers want to verify work originality, and administrators want to demonstrate academic integrity. For writing assistants and grammar tools (Grammarly, Google Docs extensions), plagiarism detection is a natural feature—users writing something probably want to know if it's plagiarism-free. For homework help platforms and tutoring services, plagiarism detection demonstrates commitment to ethical education and attracts institutions. For student portfolios and professional network tools, plagiarism detection ensures users claim credit only for original work. For AI writing tools and paraphrasing platforms, ironically, you might add plagiarism detection to allow users to verify they're not accidentally plagiarizing while using the tool. Cost is minimal: plagiarismchecker.so charges approximately $0.006 per scan (determined by text length and search depth). A B2B platform processing 10,000 student submissions monthly incurs roughly $60 in plagiarism detection costs, which can be incorporated into subscription fees. The integration takes 15-30 minutes for a basic implementation (POST to scan endpoint, check status, display results) and 2-4 hours for full-featured integration (async scanning, webhooks, custom result rendering). The value returned—institutional trust, feature differentiation, student safety—justifies the minimal integration effort.
Quick Start: Your First API Call in 5 Minutes
Getting started requires only an API key and one HTTP POST request. Generate an API key from your plagiarismchecker.so dashboard (or contact sales for B2B integration). API keys start with pe_ for security. Your first request looks like this: POST to https://plagiarismchecker.so/api/v1/scan with Content-Type: application/json. The request body includes text (required, the content to scan), search_depth (optional, 'standard' or 'deep'), and include_highlights (optional, true/false). For example, send your students' essay text to the scan endpoint and receive a response with status, scan_id, and immediate results if processing completes quickly. The response includes plagiarism_score (0-100), verdict (original, minor_similarity, moderate_plagiarism, significant_plagiarism, severe_plagiarism), matched_sources (array of sources with url, title, matched_percentage), and processing_time_ms. For your first integration, start simple: accept text from users, call the scan endpoint, display the plagiarism score and verdict to the user. This takes ten minutes to implement. Advanced features (async scanning, webhook callbacks, detailed highlight rendering) can be added later. All plagiarismchecker.so API documentation includes ready-to-run examples in cURL, Python, and Node.js, so you can test your integration immediately.
Authentication, Rate Limits, and API Key Management
plagiarismchecker.so uses API key authentication for B2B integrations and session-based authentication for end-user products. For B2B, pass your API key in the Authorization header: Authorization: Bearer pe_[your-api-key]. Keys are hashed in our database and visible only once when created, so store them securely (environment variables, secrets manager, never in code). For end-user products where you're not managing API keys, your backend authenticates the user session (via your auth system) and makes API calls on behalf of the user. Rate limits depend on your plan tier. Free tier allows 10 requests per minute. Creator tier (your first B2B plan) allows 20 requests per minute. Professional tier (enterprise) allows 60 requests per minute. Enterprise tier allows 200 requests per minute and custom limits. Requests are tracked by API key, so multiple keys under the same account are summed for limit enforcement. Each request consumes credits based on text length and search depth. Standard scans of 1,000 characters use 1 credit. Larger texts use proportionally more credits. Deep scans (full page fetching) use 2x credits. Monthly credit allotment depends on your plan. Creator tier includes 10,000 credits monthly (approximately 10,000 standard scans). Professional tier includes 50,000 credits monthly. Enterprise includes custom credits. Unused credits roll over but don't expire. If you exceed your monthly allotment, API requests are rejected with a clear error message and the user is prompted to upgrade.
Ready to check for plagiarism?
See how PlagiarismChecker detects plagiarism in your content with advanced detection.
Check NowBuilding a Scan Request: Text, Depth, and Options
Plagiarism scans accept text as plaintext (not HTML or markdown). Send the cleaned text of the student's submission. The request body includes required field text (string, 50 to 75,000 characters depending on plan) and optional fields search_depth ('standard' for snippets, 'deep' for full page fetching), include_highlights (boolean, whether to include specific matched text ranges), and async (boolean, whether to return immediately with scan_id or wait for results). For a 1,000-word essay in Creator tier, the request body is simple: { text: "The essay content...", search_depth: "standard", include_highlights: true }. The scan endpoint returns immediately with a response object containing status (PROCESSING, COMPLETED, FAILED), scan_id (unique identifier for the scan), and if status is COMPLETED, the full plagiarism_score, verdict, matched_sources array, and processing_details. If status is PROCESSING, poll the GET /api/v1/scan/[scan_id] endpoint until the scan completes. For async scans (longer documents or high traffic), include async: true in the request. You'll receive a scan_id immediately. Optionally provide callback_url, and plagiarismchecker.so will POST results to that URL when scanning completes, eliminating the need to poll. The callback payload is identical to the scan completion response. This pattern is ideal for high-volume integrations where you don't want to block user requests waiting for plagiarism results.
Parsing the Scan Response and Displaying Results
The plagiarism scan response includes the plagiarism_score (0-100 integer), verdict (string), and detailed match data. The verdict is one of: original (0-5%), minor_similarity (5-15%), moderate_plagiarism (15-40%), significant_plagiarism (40-70%), or severe_plagiarism (70%+). The matched_sources array lists each source with url, title, matched_text_percentage, match_count, and confidence_level (high for verbatim matches, medium for paraphrase matches). Display this information to your users. A minimal result view shows the score, verdict with color coding (green for original, yellow for minor, orange for moderate, red for significant/severe), and a list of matched sources. A detailed view shows character ranges of matched content, allowing users to see which specific passages triggered plagiarism flags. Include the source list with links—users should be able to click through to verify matches are legitimate. For B2B integrations, provide report download options: JSON export for LMS integration, PDF for institutional records, and CSV for analysis. The response also includes processing_time_ms and timestamp for audit logging. Educational institutions typically require audit trails (who scanned what, when, what were the results), so record this metadata alongside your plagiarism results.
Asynchronous Scanning for Scale: Webhooks and Callbacks
Synchronous scanning (POST request → wait for results → return) works fine for small-scale integrations but doesn't scale. If you process 1,000 submissions daily, and each standard scan takes 1-2 seconds, users experience 1-2 second delays while the scan completes. For high-volume products, asynchronous scanning is better. Submit the scan request with async: true and callback_url: 'https://your-domain.com/plagiarism-callback'. plagiarismchecker.so immediately returns a scan_id. Your request completes instantly. In the background, plagiarismchecker.so processes the scan and POSTs results to your callback URL when complete. Your callback handler receives the full response object, stores the results in your database (associated with the scan_id), and your frontend queries your database for results. This pattern eliminates blocking user requests and handles high volume gracefully. The callback is a POST request with content-type: application/json and includes the full response object including scan_id for linking to your records. Implement callback signature verification (plagiarismchecker.so signs callbacks with HMAC) for security. Your callback should return HTTP 200 if successfully received. If your callback is temporarily unavailable, plagiarismchecker.so retries up to 5 times with exponential backoff. For critical integrations, implement idempotence (handle duplicate callback deliveries gracefully) because network failures might cause retries. Most integrations combine both patterns: quick scans (1-2 seconds) are handled synchronously, large documents use async with callbacks.
Ready to check for plagiarism?
See how PlagiarismChecker detects plagiarism in your content with advanced detection.
Check NowError Handling, Rate Limiting, and Retry Logic
The plagiarism API returns standard HTTP status codes. 200 OK indicates successful scan submission or retrieval. 400 Bad Request indicates missing required fields or invalid parameters (text too short, search_depth invalid value). 401 Unauthorized indicates invalid or missing API key. 429 Too Many Requests indicates you've exceeded rate limits. Retry after the Retry-After header value (typically 60 seconds). 500 Internal Server Error indicates a server issue; retry with exponential backoff. Implement proper error handling in your integration. For client-side form submission, validate text length before calling the API (minimum 50 characters, maximum based on user plan). For text that's too short, tell the user the text is too brief to scan. For text that's too long, either reject it or offer to scan a longer document with the deep search option (which increases credits). When rate limited, queue the request for retry after the specified interval. Never retry more than 3-5 times; if the user is repeatedly rate-limited, prompt them to upgrade their plan. When API errors occur, display user-friendly messages. Don't expose backend errors to users. Log actual errors server-side for debugging. For production integrations, implement monitoring and alerting: track API response times (should be 1-2 seconds for standard), error rates (should be <0.1%), and credit usage (should match expected scan volume). Set up alerts if error rates spike or response times degrade.
Testing Your Integration: Sandbox Mode and Test Credentials
plagiarismchecker.so provides sandbox credentials for testing without consuming production credits. When signing up for integration, request a test API key (starts with pe_test_). This key works identically to production keys but all requests are free. Scan results are identical to production—same detection accuracy, same response format—but no credits are deducted. Use test credentials during development and QA. Before going to production, verify your integration handles all response cases: successful immediate completion (status: COMPLETED), successful async completion (status: PROCESSING, followed by callback), malformed requests (status: BAD_REQUEST), rate limiting (status: TOO_MANY_REQUESTS), and server errors (status: SERVER_ERROR). Test the full user flow: form submission → API call → result display. Test with various text lengths (short essays, long research papers, single paragraphs). Test edge cases (very short text that should be rejected, text with special characters, text in different languages). Verify result display works for all verdict types and match counts. For async testing, verify callbacks are received and results persist in your database. Once integration is tested, generate a production API key from your dashboard, update your environment variables, and deploy. Monitor the first few days of production for errors or unexpected behavior. plagiarismchecker.so provides detailed usage reporting in the dashboard so you can track API usage and costs.
Going to Production: Environment Variables, Monitoring, and Support
Deploying plagiarism detection requires a few production considerations. Store your API key in environment variables, not in code. During development, use a .env file (never commit to git). In production, set the environment variable through your hosting platform's secrets manager (Vercel Environment Variables, AWS Secrets Manager, Heroku Config Vars). Your code reads the key from the environment: const apiKey = process.env.PLAGIARISM_API_KEY; const response = await fetch('https://plagiarismchecker.so/api/v1/scan', { headers: { Authorization: `Bearer ${apiKey}` }, ... }). Monitor API performance and cost. plagiarismchecker.so's dashboard shows monthly API calls and credits consumed. Set up billing alerts if you're on a credit-based plan (Creator tier, Professional tier) so you don't suddenly exceed your allotment. If you're planning heavy usage, contact sales about Enterprise licensing (custom rate limits and custom credit packages). For business-critical integrations (LMS providers, large institutions), plagiarismchecker.so offers SLA support (uptime guarantees, priority support). Include plagiarism detection in your documentation and product tour. Explain to users what plagiarism detection does, how to interpret results, and what actions they should take if plagiarism is detected. Be transparent that you're using an external service so users understand you're respecting their privacy (detailed terms available). Test thoroughly before launch, but don't overthink it—the API is reliable and well-documented.
Ready to check for plagiarism?
See how PlagiarismChecker detects plagiarism in your content with advanced detection.
Check NowGetting Help: Documentation, Support, and Success
plagiarismchecker.so provides comprehensive integration support. The API documentation (docs.plagiarismchecker.so) includes interactive examples for all endpoints, language-specific SDKs (Python, Node.js, Go), and detailed error documentation. The blog includes integration tutorials and best practices. For integration questions, email api-support@plagiarismchecker.so or access the developer dashboard support chat. For API bugs or feature requests, contact our support team. For commercial partnerships and enterprise integrations, contact sales@plagiarismchecker.so. Most integrations work out of the box and require minimal support. The API is designed for developer experience—clear errors, predictable responses, good documentation. You should be able to get a basic integration working in under 30 minutes. If you get stuck, support is responsive and helpful. Once your integration is live, you'll likely find that plagiarism detection enhances your product's value proposition and increases user trust. Students appreciate knowing they haven't accidentally plagiarized. Teachers appreciate the ease of verification. Institutions appreciate the audit trail and comprehensive reporting. The integration effort is minimal; the value is substantial.