mirror of
https://github.com/mdtahseen7/AnimepaheApi.git
synced 2026-04-17 16:11:44 +00:00
271 lines
9.2 KiB
JavaScript
271 lines
9.2 KiB
JavaScript
const express = require('express');
|
|
const cors = require('cors');
|
|
const AnimePahe = require('./lib/animepahe');
|
|
|
|
const app = express();
|
|
const PORT = process.env.PORT || 3000;
|
|
|
|
// Middleware
|
|
app.use(cors());
|
|
app.use(express.json());
|
|
|
|
// Serve static files from public directory
|
|
app.use(express.static('public'));
|
|
|
|
// Create AnimePahe instance
|
|
const pahe = new AnimePahe();
|
|
|
|
function mapErrorToStatusCode(message) {
|
|
const text = String(message || '').toLowerCase();
|
|
if (text.includes('not found')) return 404;
|
|
if (text.includes('blocked') || text.includes('anti-bot')) return 503;
|
|
if (text.includes('forbidden')) return 403;
|
|
return 500;
|
|
}
|
|
|
|
// Routes
|
|
app.get('/', (req, res) => {
|
|
res.json({
|
|
message: 'Welcome to Animepahe API',
|
|
endpoints: {
|
|
search: '/search?q=naruto',
|
|
episodes: '/episodes?session=anime-session-id',
|
|
sources: '/sources?anime_session=xxx&episode_session=yyy',
|
|
ids: '/ids?session=anime-session-id (returns AniList and MyAnimeList IDs)',
|
|
m3u8: '/m3u8?url=kwik-url (returns m3u8 URL with required referer)',
|
|
proxy: '/proxy?url=m3u8-or-ts-url&referer=kwik-referer (Use this to play videos)',
|
|
health: '/health'
|
|
},
|
|
usage: {
|
|
note: 'Use /proxy endpoint to stream videos through the server to bypass CORS and referrer restrictions',
|
|
step1: 'Get M3U8 URL and referer from /m3u8 endpoint',
|
|
step2: 'Use the returned proxy_url directly, or use /proxy?url=<m3u8-url>&referer=<referer> in your video player',
|
|
example: '/m3u8 returns { m3u8: "...", referer: "https://kwik.si/", proxy_url: "/proxy?url=..." }'
|
|
}
|
|
});
|
|
});
|
|
|
|
app.get('/health', (req, res) => {
|
|
res.json({ status: 'ok', message: 'Animepahe API is alive!' });
|
|
});
|
|
|
|
app.get('/search', async (req, res) => {
|
|
try {
|
|
const { q } = req.query;
|
|
if (!q) {
|
|
return res.status(400).json({ error: 'Query parameter "q" is required' });
|
|
}
|
|
const results = await pahe.search(q);
|
|
res.json(results);
|
|
} catch (error) {
|
|
console.error('Search error:', error);
|
|
res.status(mapErrorToStatusCode(error.message)).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
app.get('/episodes', async (req, res) => {
|
|
try {
|
|
const { session } = req.query;
|
|
if (!session) {
|
|
return res.status(400).json({ error: 'Query parameter "session" is required' });
|
|
}
|
|
const episodes = await pahe.getEpisodes(session);
|
|
res.json(episodes);
|
|
} catch (error) {
|
|
console.error('Episodes error:', error);
|
|
res.status(mapErrorToStatusCode(error.message)).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
app.get('/sources', async (req, res) => {
|
|
try {
|
|
const { anime_session, episode_session } = req.query;
|
|
if (!anime_session || !episode_session) {
|
|
return res.status(400).json({
|
|
error: 'Query parameters "anime_session" and "episode_session" are required'
|
|
});
|
|
}
|
|
const sources = await pahe.getSources(anime_session, episode_session);
|
|
res.json(sources);
|
|
} catch (error) {
|
|
console.error('Sources error:', error);
|
|
res.status(mapErrorToStatusCode(error.message)).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
app.get('/ids', async (req, res) => {
|
|
try {
|
|
const { session } = req.query;
|
|
if (!session) {
|
|
return res.status(400).json({ error: 'Query parameter "session" is required' });
|
|
}
|
|
const ids = await pahe.getIds(session);
|
|
res.json(ids);
|
|
} catch (error) {
|
|
console.error('IDs error:', error);
|
|
res.status(mapErrorToStatusCode(error.message)).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
app.get('/m3u8', async (req, res) => {
|
|
try {
|
|
const { url } = req.query;
|
|
if (!url) {
|
|
return res.status(400).json({ error: 'Query parameter "url" is required' });
|
|
}
|
|
const result = await pahe.resolveKwikWithNode(url);
|
|
|
|
// Return m3u8 URL along with required referer for CORS bypass
|
|
res.json({
|
|
m3u8: result.m3u8,
|
|
referer: result.referer,
|
|
headers: {
|
|
'Referer': result.referer,
|
|
'Origin': result.origin
|
|
},
|
|
proxy_url: `/proxy?url=${encodeURIComponent(result.m3u8)}&referer=${encodeURIComponent(result.referer)}`
|
|
});
|
|
} catch (error) {
|
|
console.error('M3U8 resolution error:', error);
|
|
res.status(mapErrorToStatusCode(error.message)).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
app.get('/proxy', async (req, res) => {
|
|
try {
|
|
const { url, referer: customReferer } = req.query;
|
|
if (!url) {
|
|
return res.status(400).json({
|
|
error: 'Query parameter "url" is required',
|
|
usage: 'GET /proxy?url=<m3u8-or-ts-url>&referer=<optional-referer>',
|
|
example: '/proxy?url=https://example.com/video.m3u8&referer=https://kwik.si/'
|
|
});
|
|
}
|
|
|
|
const axios = require('axios');
|
|
|
|
// Use custom referer if provided, otherwise extract from URL
|
|
const urlObj = new URL(url);
|
|
const referer = customReferer || `${urlObj.protocol}//${urlObj.host}/`;
|
|
|
|
// Fetch the content with proper headers
|
|
const response = await axios.get(url, {
|
|
headers: {
|
|
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
|
|
'Referer': referer,
|
|
'Origin': referer.slice(0, -1),
|
|
'Accept': '*/*',
|
|
'Accept-Language': 'en-US,en;q=0.9',
|
|
'Accept-Encoding': 'gzip, deflate, br',
|
|
'Connection': 'keep-alive',
|
|
'Sec-Fetch-Dest': 'empty',
|
|
'Sec-Fetch-Mode': 'cors',
|
|
'Sec-Fetch-Site': 'cross-site'
|
|
},
|
|
responseType: 'arraybuffer',
|
|
timeout: 30000,
|
|
maxRedirects: 5,
|
|
validateStatus: function (status) {
|
|
return status >= 200 && status < 500; // Accept 4xx errors to handle them
|
|
}
|
|
});
|
|
|
|
// Check if we got blocked
|
|
if (response.status === 403) {
|
|
return res.status(403).json({
|
|
error: 'Access forbidden - CDN blocked the request',
|
|
suggestion: 'The video CDN is blocking server requests. Try using a browser extension or different source.',
|
|
url: url
|
|
});
|
|
}
|
|
|
|
// Determine content type
|
|
const contentType = response.headers['content-type'] ||
|
|
(url.includes('.m3u8') ? 'application/vnd.apple.mpegurl' :
|
|
url.includes('.ts') ? 'video/mp2t' : 'application/octet-stream');
|
|
|
|
// If it's an m3u8 playlist, modify URLs to go through proxy
|
|
if (contentType.includes('mpegurl') || url.includes('.m3u8')) {
|
|
let content = response.data.toString('utf-8');
|
|
|
|
// Replace relative URLs with proxied absolute URLs
|
|
const baseUrl = url.substring(0, url.lastIndexOf('/') + 1);
|
|
const refererParam = customReferer ? `&referer=${encodeURIComponent(customReferer)}` : '';
|
|
content = content.split('\n').map(line => {
|
|
line = line.trim();
|
|
if (line && !line.startsWith('#') && !line.startsWith('http')) {
|
|
// Relative URL - make it absolute and proxy it
|
|
const absoluteUrl = baseUrl + line;
|
|
return `/proxy?url=${encodeURIComponent(absoluteUrl)}${refererParam}`;
|
|
} else if (line.startsWith('http')) {
|
|
// Absolute URL - proxy it
|
|
return `/proxy?url=${encodeURIComponent(line)}${refererParam}`;
|
|
}
|
|
return line;
|
|
}).join('\n');
|
|
|
|
res.setHeader('Content-Type', contentType);
|
|
res.setHeader('Access-Control-Allow-Origin', '*');
|
|
res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
|
|
res.setHeader('Access-Control-Allow-Headers', 'Range, Content-Type');
|
|
res.send(content);
|
|
} else {
|
|
// Video segment or other binary content
|
|
res.setHeader('Content-Type', contentType);
|
|
res.setHeader('Access-Control-Allow-Origin', '*');
|
|
res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
|
|
res.setHeader('Access-Control-Allow-Headers', 'Range, Content-Type');
|
|
res.setHeader('Accept-Ranges', 'bytes');
|
|
|
|
if (response.headers['content-length']) {
|
|
res.setHeader('Content-Length', response.headers['content-length']);
|
|
}
|
|
|
|
res.send(Buffer.from(response.data));
|
|
}
|
|
} catch (error) {
|
|
console.error('Proxy error:', error.message);
|
|
|
|
if (error.response && error.response.status === 403) {
|
|
return res.status(403).json({
|
|
error: 'Access forbidden - CDN blocked the request',
|
|
suggestion: 'The video CDN has Cloudflare protection. You may need to use a CORS proxy service or browser extension.',
|
|
url: req.query.url
|
|
});
|
|
}
|
|
|
|
res.status(500).json({
|
|
error: error.message,
|
|
url: req.query.url,
|
|
suggestion: 'Try accessing the M3U8 URL directly in your browser or use a CORS proxy service'
|
|
});
|
|
}
|
|
});
|
|
|
|
// Handle OPTIONS for CORS preflight
|
|
app.options('/proxy', (req, res) => {
|
|
res.setHeader('Access-Control-Allow-Origin', '*');
|
|
res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
|
|
res.setHeader('Access-Control-Allow-Headers', 'Range, Content-Type');
|
|
res.sendStatus(200);
|
|
});
|
|
|
|
// Global error handler
|
|
app.use((err, req, res, next) => {
|
|
console.error('Unhandled error:', err);
|
|
res.status(500).json({
|
|
error: 'Internal server error',
|
|
message: err.message
|
|
});
|
|
});
|
|
|
|
// Export for Vercel
|
|
module.exports = app;
|
|
|
|
// Start server if not in Vercel environment
|
|
if (require.main === module) {
|
|
app.listen(PORT, () => {
|
|
console.log(`Animepahe API server running on port ${PORT}`);
|
|
});
|
|
}
|