@lmna22/aio-downloader 1.0.1

package/src/lib/instagram.js

@@ -0,0 +1,395 @@
+const axios = require('axios');
+const cheerio = require('cheerio');
+const qs = require('qs');
+
+const HEADERS = {
+    Accept: '*/*',
+    'Accept-Language': 'en-US,en;q=0.5',
+    'Content-Type': 'application/x-www-form-urlencoded',
+    'X-FB-Friendly-Name': 'PolarisPostActionLoadPostQueryQuery',
+    'X-CSRFToken': 'RVDUooU5MYsBbS1CNN3CzVAuEP8oHB52',
+    'X-IG-App-ID': '1217981644879628',
+    'X-FB-LSD': 'AVqbxe3J_YA',
+    'X-ASBD-ID': '129477',
+    'Sec-Fetch-Dest': 'empty',
+    'Sec-Fetch-Mode': 'cors',
+    'Sec-Fetch-Site': 'same-origin',
+    'User-Agent': 'Mozilla/5.0 (Linux; Android 11; SAMSUNG SM-G973U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/14.2 Chrome/87.0.4280.141 Mobile Safari/537.36'
+};
+
+function getInstagramPostId(url) {
+    const regex = /(?:https?:\/\/)?(?:www\.)?instagram\.com\/(?:p|tv|reel)\/([^/?#&]+).*/;
+    const match = url.match(regex);
+    return match ? match[1] : null;
+}
+
+function encodeGraphqlRequestData(shortcode) {
+    const requestData = {
+        av: "0",
+        __d: "www",
+        __user: "0",
+        __a: "1",
+        __req: "3",
+        __hs: "19624.HYP:instagram_web_pkg.2.1..0.0",
+        dpr: "3",
+        __ccg: "UNKNOWN",
+        __rev: "1008824440",
+        __s: "xf44ne:zhh75g:xr51e7",
+        __hsi: "7282217488877343271",
+        __dyn: "7xeUmwlEnwn8K2WnFw9-2i5U4e0yoW3q32360CEbo1nEhw2nVE4W0om78b87C0yE5ufz81s8hwGwQwoEcE7O2l0Fwqo31w9a9x-0z8-U2zxe2GewGwso88cobEaU2eUlwhEe87q7-0iK2S3qazo7u1xwIw8O321LwTwKG1pg661pwr86C1mwraCg",
+        __csr: "gZ3yFmJkillQvV6ybimnG8AmhqujGbLADgjyEOWz49z9XDlAXBJpC7Wy-vQTSvUGWGh5u8KibG44dBiigrgjDxGjU0150Q0848azk48N09C02IR0go4SaR70r8owyg9pU0V23hwiA0LQczA48S0f-x-27o05NG0fkw",
+        __comet_req: "7",
+        lsd: "AVqbxe3J_YA",
+        jazoest: "2957",
+        __spin_r: "1008824440",
+        __spin_b: "trunk",
+        __spin_t: "1695523385",
+        fb_api_caller_class: "RelayModern",
+        fb_api_req_friendly_name: "PolarisPostActionLoadPostQueryQuery",
+        variables: JSON.stringify({
+            shortcode: shortcode,
+            fetch_comment_count: null,
+            fetch_related_profile_media_count: null,
+            parent_comment_count: null,
+            child_comment_count: null,
+            fetch_like_count: null,
+            fetch_tagged_user_count: null,
+            fetch_preview_comment_count: null,
+            has_threaded_comments: false,
+            hoisted_comment_id: null,
+            hoisted_reply_id: null,
+        }),
+        server_timestamps: "true",
+        doc_id: "10015901848480474",
+    };
+
+    return qs.stringify(requestData);
+}
+
+async function getPostGraphqlData(postId, proxy) {
+    const encodedData = encodeGraphqlRequestData(postId);
+    const response = await axios.post('https://www.instagram.com/api/graphql', encodedData, { headers: HEADERS, httpsAgent: proxy });
+    return response.data;
+}
+
+function extractPostInfo(mediaData) {
+    const getUrlFromData = (data) => {
+        if (data.edge_sidecar_to_children) {
+            return data.edge_sidecar_to_children.edges
+                .map(edge => edge.node.video_url || edge.node.display_url);
+        }
+        return data.video_url ? [data.video_url] : [data.display_url];
+    };
+
+    return {
+        creator: '@fort.kun',
+        status: true,
+        data: {
+            url: getUrlFromData(mediaData),
+            caption: mediaData.edge_media_to_caption.edges[0]?.node.text || null,
+            username: mediaData.owner.username,
+            like: mediaData.edge_media_preview_like.count,
+            comment: mediaData.edge_media_to_comment.count,
+            isVideo: mediaData.is_video,
+        }
+    };
+}
+
+async function directScrape(url, proxy = null) {
+    try {
+        const postId = getInstagramPostId(url);
+        if (!postId) {
+            throw new Error('Invalid Instagram URL');
+        }
+
+        const data = await getPostGraphqlData(postId, proxy);
+        const mediaData = data.data?.xdt_shortcode_media;
+
+        if (!mediaData) {
+            return null;
+        }
+
+        return extractPostInfo(mediaData);
+    } catch (error) {
+        return {
+            creator: '@fort.kun',
+            status: false,
+            message: error.message
+        };
+    }
+}
+
+const varHeaders = {
+    'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+    'accept-language': 'en-US,en;q=0.9',
+    'cache-control': 'no-cache',
+    'sec-ch-prefers-color-scheme': 'light',
+    'sec-ch-ua': '"Chromium";v="110", "Not A(Brand";v="24", "Microsoft Edge";v="110"',
+    'sec-ch-ua-mobile': '?0',
+    'sec-ch-ua-platform': '"Windows"',
+    'sec-fetch-dest': 'document',
+    'sec-fetch-mode': 'navigate',
+    'sec-fetch-site': 'same-origin',
+    'sec-fetch-user': '?1',
+    'upgrade-insecure-requests': '1',
+    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/124.0.0.0',
+};
+
+let grapHeaders = {
+    'Accept': 'application/json',
+    'Accept-Language': 'en-US,en;q=0.9',
+    'Cache-Control': 'no-cache',
+    'Dnt': '1',
+    'Pragma': 'no-cache',
+    'Referer': '',
+    'Sec-Fetch-Dest': 'empty',
+    'Sec-Fetch-Mode': 'cors',
+    'Sec-Fetch-Site': 'same-origin',
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 Edg/124.0.0.0',
+    'X-Csrftoken': 'EuZcvVSeiRAC60CJQRrRC6',
+    'X-Ig-App-Id': '936619743392459',
+    'X-Ig-Www-Claim': '0',
+    'X-Requested-With': 'XMLHttpRequest'
+};
+
+async function userGraphql(url) {
+    try {
+        let body = await axios.get(url, {
+            headers: varHeaders,
+        }).then(res => res.data);
+
+        let user_id = body.match(/<meta\s+property="instapp:owner_user_id"\s+content="(\d+)"/)[1];
+        let video_id = body.match(/instagram:\/\/media\?id=(\d+)/)[1];
+
+        const graphUrl = `https://www.instagram.com/graphql/query/?doc_id=7571407972945935&variables=%7B%22id%22%3A%22${user_id}%22%2C%22include_clips_attribution_info%22%3Afalse%2C%22first%22%3A1000%7D`;
+
+        const graph = await axios.get(graphUrl, {
+            method: 'GET',
+            headers: grapHeaders,
+        }).then(response => response.data);
+
+        const edges = graph.data.user.edge_owner_to_timeline_media.edges;
+        let videoData = edges.find(edge => edge.node.id === video_id);
+
+        if (!videoData) {
+            return {
+                creator: '@fort.kun',
+                status: false,
+                message: 'Video not found'
+            };
+        }
+
+        videoData = videoData.node;
+
+        const getUrlFromData = (videoData) => {
+            if (videoData.edge_sidecar_to_children) {
+                return videoData.edge_sidecar_to_children.edges
+                    .map(edge => edge.node.video_url || edge.node.display_url);
+            }
+            return videoData.video_url ? [videoData.video_url] : [videoData.display_url];
+        };
+
+        const listUrl = getUrlFromData(videoData);
+
+        return {
+            creator: '@fort.kun',
+            status: true,
+            data: {
+                url: listUrl,
+                caption: videoData['edge_media_to_caption']['edges'].length > 0 ? videoData['edge_media_to_caption']['edges'][0]['node']['text'] : null,
+                username: videoData['owner']['username'],
+                like: videoData['edge_media_preview_like']['count'],
+                comment: videoData['edge_media_to_comment']['count'],
+                isVideo: videoData['is_video'],
+            }
+        };
+    } catch (error) {
+        return {
+            creator: '@fort.kun',
+            status: false,
+            message: error.message
+        };
+    }
+}
+
+async function saveIG(query) {
+    try {
+        const requestData = {
+            q: query,
+            t: 'media',
+            lang: 'en'
+        };
+
+        const requestHeaders = {
+            Accept: '*/*',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Origin: 'https://saveig.app',
+            Referer: 'https://saveig.app/en',
+            'Sec-Ch-Ua': '"Not/A)Brand";v="99", "Microsoft Edge";v="115", "Chromium";v="115"',
+            'Sec-Ch-Ua-Mobile': '?0',
+            'Sec-Ch-Ua-Platform': '"Windows"',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.183',
+            'X-Requested-With': 'XMLHttpRequest'
+        };
+
+        const axiosInstance = axios.create({ headers: requestHeaders });
+
+        const [response] = await Promise.all([
+            axiosInstance.post('https://saveig.app/api/ajaxSearch', qs.stringify(requestData))
+        ]);
+
+        const responseData = response.data;
+        const htmlContent = responseData.data;
+
+        const $ = cheerio.load(htmlContent);
+        const downloadItems = $('.download-items');
+
+        const downloadLinks = [];
+        downloadItems.each((index, element) => {
+            const downloadLink = $(element).find('.download-items__btn > a').attr('href');
+            downloadLinks.push(downloadLink);
+        });
+
+        return {
+            creator: '@fort.kun',
+            status: true,
+            data: {
+                url: downloadLinks,
+                caption: null,
+                username: null,
+                like: null,
+                comment: null,
+                isVideo: null,
+            }
+        };
+    } catch (error) {
+        return {
+            creator: '@fort.kun',
+            status: false,
+            message: error.message
+        };
+    }
+}
+
+function extractData(script) {
+    const regex = /downVideo\('([^']+)'.*?\.mp([34])/g;
+    const regex2 = /window\.open\("([^"]+)"/g;
+
+    let videoUrl = [];
+
+    let match;
+    while ((match = regex.exec(script)) !== null) {
+        const url = match[1];
+        const fileType = match[2];
+
+        if (fileType === '4') {
+            videoUrl.push('https:' + url);
+        } else if (fileType === '3') {
+            videoUrl.push(url);
+        }
+    }
+
+    while ((match = regex2.exec(script)) !== null) {
+        const url = match[1];
+        videoUrl.push(url);
+    }
+
+    return videoUrl;
+}
+
+async function dlpanda(url) {
+    try {
+        let result = await axios.get(`https://dlpanda.com/instagram?url=${url}`).then(response => {
+            return response.data;
+        });
+
+        let downloadLinks = extractData(result);
+        if (downloadLinks.length === 0) {
+            return {
+                creator: '@fort.kun',
+                status: false,
+                message: 'No video found'
+            };
+        }
+
+        return {
+            creator: '@fort.kun',
+            status: true,
+            data: {
+                url: downloadLinks,
+                caption: null,
+                username: null,
+                like: null,
+                comment: null,
+                isVideo: null,
+            }
+        };
+    } catch (error) {
+        return {
+            creator: '@fort.kun',
+            status: false,
+            message: error.message
+        };
+    }
+}
+
+async function instagramDownloader(text, Func) {
+    const methods = [
+        async () => {
+            try {
+                const data = await directScrape(text);
+                if (!data || !data.status) return null;
+                return data;
+            } catch (error) {
+                return null;
+            }
+        },
+        async () => {
+            try {
+                const data = await userGraphql(text);
+                if (!data.status) return null;
+                return data;
+            } catch (error) {
+                return null;
+            }
+        },
+        async () => {
+            try {
+                const data = await saveIG(text);
+                if (!data.status) return null;
+                return data;
+            } catch (error) {
+                return null;
+            }
+        },
+        async () => {
+            try {
+                const data = await dlpanda(text);
+                if (!data.status) return null;
+                return data;
+            } catch (error) {
+                return null;
+            }
+        },
+    ];
+
+    for (const method of methods) {
+        const info = await method();
+        if (info !== null && info.status) {
+            return info;
+        }
+    }
+
+    return {
+        creator: '@fort.kun',
+        status: false,
+        message: 'All methods failed'
+    };
+}
+
+module.exports = instagramDownloader;

package/src/lib/pinterest.js

@@ -0,0 +1,313 @@
+const axios = require("axios");
+const cheerio = require("cheerio");
+const { DEFAULT_UA, cleanText, safeJsonParse, uniqBy, isValidUrl } = require("../utils");
+
+function isPinterestUrl(text) {
+    try {
+        const u = new URL(text);
+        return u.hostname.includes("pinterest.");
+    } catch {
+        return false;
+    }
+}
+
+function buildSearchUrl(query) {
+    return `https://www.pinterest.com/search/pins/?q=${encodeURIComponent(query)}`;
+}
+
+function normalizePinterestPinUrl(url, id = null) {
+    if (!url && id) return `https://www.pinterest.com/pin/${id}/`;
+    if (!url) return null;
+
+    try {
+        const u = new URL(url, "https://www.pinterest.com");
+        if (!u.hostname.includes("pinterest.")) return url;
+
+        const match = u.pathname.match(/\/pin\/(\d+)/);
+        if (match) return `https://www.pinterest.com/pin/${match[1]}/`;
+        if (id) return `https://www.pinterest.com/pin/${id}/`;
+        return u.toString();
+    } catch {
+        const match = String(url).match(/\/pin\/(\d+)/);
+        if (match) return `https://www.pinterest.com/pin/${match[1]}/`;
+        if (id) return `https://www.pinterest.com/pin/${id}/`;
+        return url;
+    }
+}
+
+function normalizePin(pin) {
+    if (!pin || typeof pin !== "object") return null;
+
+    const id = pin.id || pin.pinId || pin.pin_id || pin.aggregated_pin_data?.id || null;
+
+    const title = cleanText(
+        pin.title || pin.grid_title || pin.seo_description || pin.description ||
+        pin.rich_summary?.display_description || pin.story_pin_data?.title || pin.alt_text || null
+    );
+
+    if (title && title.toLowerCase() === "pin") return null;
+
+    const rawLink = pin.link || pin.url || pin.closeup_unified_description?.url || pin.canonical_url || null;
+    const link = normalizePinterestPinUrl(rawLink, id);
+
+    const image =
+        pin.images?.orig?.url || pin.images?.["736x"]?.url || pin.images?.["564x"]?.url ||
+        pin.images?.["474x"]?.url || pin.images?.["236x"]?.url || pin.image_medium_url ||
+        pin.image_large_url || pin.image_url || pin.story_pin_data?.pages?.[0]?.image?.images?.orig?.url ||
+        pin.videos?.video_list?.V_720P?.url || pin.videos?.video_list?.V_EXP3?.url || null;
+
+    const source = pin.domain || pin.rich_metadata?.site_name || pin.tracking_params?.domain || null;
+
+    if (!id && !title && !link && !image) return null;
+
+    return {
+        id: id ? String(id) : null,
+        title: title || null,
+        link: link || null,
+        image: isValidUrl(image) ? image : null,
+        source: source || null,
+    };
+}
+
+function deepCollectPins(obj, bucket = []) {
+    if (!obj || typeof obj !== "object") return bucket;
+
+    if (Array.isArray(obj)) {
+        for (const item of obj) deepCollectPins(item, bucket);
+        return bucket;
+    }
+
+    const looksLikePin =
+        ("id" in obj || "pinId" in obj || "pin_id" in obj) &&
+        ("images" in obj || "image_url" in obj || "image_medium_url" in obj ||
+            "title" in obj || "grid_title" in obj || "description" in obj ||
+            "link" in obj || "url" in obj);
+
+    if (looksLikePin) {
+        const parsed = normalizePin(obj);
+        if (parsed) bucket.push(parsed);
+    }
+
+    for (const value of Object.values(obj)) deepCollectPins(value, bucket);
+    return bucket;
+}
+
+function parseScriptJsonById(html, scriptId) {
+    const $ = cheerio.load(html);
+    const raw = $(`script#${scriptId}`).html();
+    if (!raw) return [];
+    const json = safeJsonParse(raw);
+    if (!json) return [];
+    return uniqBy(deepCollectPins(json), (x) => x.id || x.link || x.image);
+}
+
+function parseMetaFallback(html, pageUrl = null) {
+    const $ = cheerio.load(html);
+
+    const title =
+        cleanText($('meta[property="og:title"]').attr("content")) ||
+        cleanText($('meta[name="twitter:title"]').attr("content")) ||
+        cleanText($("title").text());
+
+    const image =
+        $('meta[property="og:image"]').attr("content") ||
+        $('meta[name="twitter:image"]').attr("content") || null;
+
+    const canonical =
+        $('link[rel="canonical"]').attr("href") ||
+        $('meta[property="og:url"]').attr("content") || pageUrl || null;
+
+    const normalizedLink = normalizePinterestPinUrl(canonical, null);
+    const idMatch = normalizedLink ? normalizedLink.match(/\/pin\/(\d+)\//) : null;
+    const id = idMatch ? idMatch[1] : null;
+
+    if (!id && !title && !image && !normalizedLink) return [];
+
+    return [{
+        id: id || null,
+        title: title || null,
+        link: normalizedLink || null,
+        image: isValidUrl(image) ? image : null,
+        source: null,
+    }];
+}
+
+function parseFromRenderedDom(html) {
+    const $ = cheerio.load(html);
+    const results = [];
+
+    $("a[href*='/pin/']").each((_, el) => {
+        const a = $(el);
+        const href = a.attr("href");
+        if (!href) return;
+
+        const fullLink = href.startsWith("http") ? href : `https://www.pinterest.com${href}`;
+        if (/\/repin\/?/i.test(fullLink)) return;
+        if (/\/pin\/create\//i.test(fullLink)) return;
+
+        const normalizedLink = normalizePinterestPinUrl(fullLink);
+        const idMatch = normalizedLink.match(/\/pin\/(\d+)\//);
+        if (!idMatch) return;
+
+        const img = a.find("img").first().length ? a.find("img").first() : a.closest("*").find("img").first();
+
+        const title = cleanText(img.attr("alt") || a.attr("aria-label") || a.text().trim() || null);
+
+        const image = img.attr("src") || img.attr("data-src") ||
+            img.attr("srcset")?.split(",").pop()?.trim().split(" ")[0] || null;
+
+        results.push({
+            id: idMatch[1],
+            title: title || null,
+            link: normalizedLink,
+            image: isValidUrl(image) ? image : null,
+            source: null,
+        });
+    });
+
+    return uniqBy(results, (x) => x.id || x.link || x.image);
+}
+
+function scorePin(pin) {
+    let score = 0;
+    if (pin.id) score += 3;
+    if (pin.link && /\/pin\/\d+\/$/i.test(pin.link)) score += 4;
+    if (pin.image) score += 4;
+    if (pin.title) score += 2;
+    if (pin.source) score += 1;
+    if (pin.link && /\/repin\/?/i.test(pin.link)) score -= 10;
+    return score;
+}
+
+function cleanFinalResults(results) {
+    const cleaned = results
+        .map((item) => ({
+            id: item.id ? String(item.id) : null,
+            title: cleanText(item.title),
+            link: normalizePinterestPinUrl(item.link, item.id),
+            image: isValidUrl(item.image) ? item.image : null,
+            source: item.source || null,
+        }))
+        .filter((item) => item.id || item.title || item.link || item.image);
+
+    const deduped = uniqBy(cleaned, (x) => x.id || x.link || x.image);
+    deduped.sort((a, b) => scorePin(b) - scorePin(a));
+    return deduped;
+}
+
+async function fetchHtmlWithAxios(url) {
+    const res = await axios.get(url, {
+        headers: {
+            "User-Agent": DEFAULT_UA,
+            "Accept-Language": "en-US,en;q=0.9",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+            "Referer": "https://www.pinterest.com/",
+        },
+        timeout: 30000,
+        maxRedirects: 5,
+    });
+    return res.data;
+}
+
+async function fetchHtmlWithPuppeteer(url) {
+    let puppeteer;
+    try {
+        puppeteer = require("puppeteer");
+    } catch {
+        throw new Error("Puppeteer is required for this Pinterest URL but is not installed. Install it with: npm install puppeteer");
+    }
+
+    const browser = await puppeteer.launch({
+        headless: true,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"],
+    });
+
+    try {
+        const page = await browser.newPage();
+        await page.setUserAgent(DEFAULT_UA);
+        await page.setExtraHTTPHeaders({ "Accept-Language": "en-US,en;q=0.9" });
+        await page.goto(url, { waitUntil: "networkidle2", timeout: 60000 });
+
+        await new Promise((r) => setTimeout(r, 5000));
+
+        await page.evaluate(async () => {
+            await new Promise((resolve) => {
+                let totalHeight = 0;
+                const distance = 800;
+                const timer = setInterval(() => {
+                    window.scrollBy(0, distance);
+                    totalHeight += distance;
+                    if (totalHeight >= 5000) { clearInterval(timer); resolve(); }
+                }, 400);
+            });
+        });
+
+        await new Promise((r) => setTimeout(r, 2000));
+        return await page.content();
+    } finally {
+        await browser.close();
+    }
+}
+
+async function pinterestDownloader(input, options = {}) {
+    const limit = options.limit || 10;
+
+    let isUrl = false;
+    try { new URL(input); isUrl = true; } catch { }
+
+    const inputIsPinterest = isUrl && isPinterestUrl(input);
+    const singleMode = isUrl && inputIsPinterest;
+    const url = isUrl ? input : buildSearchUrl(input);
+
+    let html;
+    let method = "axios";
+
+    try {
+        html = await fetchHtmlWithAxios(url);
+        const candidates = cleanFinalResults([
+            ...parseScriptJsonById(html, "__PWS_DATA__"),
+            ...parseScriptJsonById(html, "__PWS_INITIAL_PROPS__"),
+            ...parseFromRenderedDom(html),
+            ...parseMetaFallback(html, url),
+        ]);
+        if (candidates.length === 0) throw new Error("No results from axios");
+    } catch {
+        html = await fetchHtmlWithPuppeteer(url);
+        method = "puppeteer";
+    }
+
+    let finalResults = cleanFinalResults([
+        ...parseScriptJsonById(html, "__PWS_DATA__"),
+        ...parseScriptJsonById(html, "__PWS_INITIAL_PROPS__"),
+        ...parseFromRenderedDom(html),
+        ...parseMetaFallback(html, url),
+    ]);
+
+    if (singleMode) {
+        const exactPinId = url.match(/\/pin\/(\d+)/)?.[1] || null;
+        if (exactPinId) {
+            finalResults.sort((a, b) => {
+                const aExact = a.id === exactPinId ? 1 : 0;
+                const bExact = b.id === exactPinId ? 1 : 0;
+                return bExact - aExact || scorePin(b) - scorePin(a);
+            });
+        }
+        finalResults = finalResults.slice(0, 1);
+    } else {
+        finalResults = finalResults.slice(0, limit);
+    }
+
+    if (finalResults.length === 0) {
+        throw new Error("No Pinterest pin data found. The page may require authentication or the URL is invalid.");
+    }
+
+    return {
+        status: "ok",
+        platform: "pinterest",
+        method,
+        total: finalResults.length,
+        results: finalResults,
+    };
+}
+
+module.exports = pinterestDownloader;