├── assets
    └── logo.webp
├── scrapers
    ├── __pycache__
    │   ├── azm.cpython-310.pyc
    │   ├── filecdn.cpython-310.pyc
    │   ├── frembed.cpython-310.pyc
    │   ├── downloads.cpython-310.pyc
    │   ├── showflix.cpython-310.pyc
    │   ├── streamium.cpython-310.pyc
    │   ├── subtitles.cpython-310.pyc
    │   ├── twoembed.cpython-310.pyc
    │   ├── vidsrcme.cpython-310.pyc
    │   ├── vidsrcto.cpython-310.pyc
    │   ├── vixcloud.cpython-310.pyc
    │   ├── dreamfilmsw.cpython-310.pyc
    │   └── meinecloud.cpython-310.pyc
    ├── embeds
    │   ├── __pycache__
    │   │   ├── dood.cpython-310.pyc
    │   │   └── streamwish.cpython-310.pyc
    │   ├── showflix.py
    │   ├── streamwish.py
    │   ├── uqload.py
    │   ├── voe.py
    │   ├── upstream.py
    │   └── dood.py
    ├── meinecloud.py
    ├── frembed.py
    ├── filecdn.py
    ├── extractors
    │   └── megacloud.py
    ├── subtitles.py
    ├── streamium.py
    ├── showflix.py
    ├── unfinished
    │   ├── vidsrcme.py
    │   └── uhdmovies.py
    ├── downloads.py
    ├── twoembed.py
    ├── utils
    │   └── unpacker.py
    ├── vidsrcto.py
    ├── dreamfilmsw.py
    ├── azm.py
    ├── vidsrcme.py
    ├── vixcloud.py
    └── flixhq.py
├── requirements.txt
├── README.md
└── main.py


/assets/logo.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/assets/logo.webp


--------------------------------------------------------------------------------
/scrapers/__pycache__/azm.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/azm.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/filecdn.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/filecdn.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/frembed.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/frembed.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/downloads.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/downloads.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/showflix.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/showflix.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/streamium.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/streamium.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/subtitles.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/subtitles.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/twoembed.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/twoembed.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/vidsrcme.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/vidsrcme.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/vidsrcto.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/vidsrcto.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/vixcloud.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/vixcloud.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/dreamfilmsw.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/dreamfilmsw.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/__pycache__/meinecloud.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/__pycache__/meinecloud.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/embeds/__pycache__/dood.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/embeds/__pycache__/dood.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/embeds/__pycache__/streamwish.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/streamflix-one/providers/HEAD/scrapers/embeds/__pycache__/streamwish.cpython-310.pyc


--------------------------------------------------------------------------------
/scrapers/embeds/showflix.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import re
 3 | 
 4 | class ShowFlix:
 5 |     def __init__(self, url):
 6 |         self.url = url
 7 | 
 8 |     def main(self):
 9 |         headers = {
10 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
11 |             "Accept-Language": "en-GB,en;q=0.9",
12 |             "Connection": "keep-alive",
13 |             "Host": "showflix.cfd",
14 |             "Referer": "https://showflix.lol/",
15 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
16 |             "sec-ch-ua-mobile": "?0",
17 |             "sec-ch-ua-platform": '"Windows"',
18 |             "Sec-Fetch-Dest": "iframe",
19 |             "Sec-Fetch-Mode": "navigate",
20 |             "Sec-Fetch-Site": "cross-site",
21 |             "Sec-Fetch-User": "?1",
22 |             "Sec-GPC": "1",
23 |             "Upgrade-Insecure-Requests": "1",
24 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
25 |         }
26 | 
27 |         response = requests.get(self.url, headers=headers)
28 |         html_content = response.text
29 | 
30 |         m3u8_url_match = re.search(r'sources: \[\{[^}]*file:\s*"([^"]+)"[^}]*\}\]', html_content)
31 |         if m3u8_url_match:
32 |             m3u8_url = m3u8_url_match.group(1)
33 |             return m3u8_url
34 |         else:
35 |             return None
36 | 
37 | 


--------------------------------------------------------------------------------
/scrapers/meinecloud.py:
--------------------------------------------------------------------------------
 1 | import cloudscraper
 2 | import re
 3 | import requests
 4 | from scrapers.embeds.dood import Doodstream
 5 | 
 6 | class MeineCloud:
 7 |     def __init__(self, tmdb_api_key):
 8 |         self.scraper = cloudscraper.create_scraper()
 9 |         self.tmdb_api_key = tmdb_api_key
10 | 
11 |     def fetch_sources(self, user_ip, tmdb_id):
12 |         imdb_id = self._get_imdb_id(tmdb_id)
13 |         html_content = self.scraper.get(f"https://meinecloud.click/movie/{imdb_id}").text
14 |         pattern = r'<li class data-link="(//dood\.to/e/[a-zA-Z0-9]+)">'
15 | 
16 |         matches = re.findall(pattern, html_content)
17 |         if matches:
18 |             dood_id = matches[0].split("/e/")[1]
19 |             formatted_url = f"https://d0o0d.com/e/{dood_id}?"
20 |             doodstream = Doodstream(formatted_url, user_ip)
21 |             r = doodstream.main().split("\n")[0]
22 |             print(r)
23 |             return {'url': f'{r}#.mp4', 'source': 'MeineCloud', 'proxy': 'False', 'lang': 'de', 'type': 'mp4'}
24 |         else:
25 |             return None
26 | 
27 |     def _get_imdb_id(self, tmdb_id):
28 |         tmdb_api_url = f"https://api.themoviedb.org/3/movie/{tmdb_id}?api_key={self.tmdb_api_key}"
29 |         response = requests.get(tmdb_api_url)
30 |         if response.status_code == 200:
31 |             data = response.json()
32 |             imdb_id = data.get("imdb_id", "")
33 |             return imdb_id
34 |         else:
35 |             raise ValueError(f"Error fetching IMDb ID from TMDB API. Status Code: {response.status_code}")
36 | 


--------------------------------------------------------------------------------
/scrapers/embeds/streamwish.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import re
 3 | 
 4 | class Streamwish:
 5 |     def __init__(self, url, ip):
 6 |         self.url = url
 7 |         self.user_ip = ip
 8 | 
 9 |     def main(self):
10 |         headers = {
11 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
12 |             "Accept-Language": "en-GB,en;q=0.9",
13 |             "Connection": "keep-alive",
14 |             "Host": f"{self.url.split('/e/')[0].strip('https://')}",
15 |             "Referer": "https://showflix.lol/", # showflix for everything cause why not 
16 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
17 |             "sec-ch-ua-mobile": "?0",
18 |             "sec-ch-ua-platform": '"Windows"',
19 |             "Sec-Fetch-Dest": "iframe",
20 |             "Sec-Fetch-Mode": "navigate",
21 |             "Sec-Fetch-Site": "cross-site",
22 |             "Sec-Fetch-User": "?1",
23 |             "Sec-GPC": "1",
24 |             "Upgrade-Insecure-Requests": "1",
25 |             "X-Forwarded-For": self.user_ip,
26 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
27 |         }
28 | 
29 |         response = requests.get(self.url, headers=headers)
30 |         html_content = response.text
31 |         m3u8_url_match = re.search(r'sources: \[\{[^}]*file:\s*"([^"]+)"[^}]*\}\]', html_content)
32 |         if m3u8_url_match:
33 |             m3u8_url = m3u8_url_match.group(1)
34 |             return m3u8_url
35 |         else:
36 |             return None
37 | 
38 | 


--------------------------------------------------------------------------------
/scrapers/frembed.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import re
 3 | 
 4 | class FrEmbed:
 5 |     def __init__(self):
 6 |         self.headers = {
 7 |             "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 8 |             "accept-language": "en-GB,en;q=0.9",
 9 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
10 |             "Connection": "keep-alive",
11 |             "Host": "frembed.fun",
12 |             "sec-ch-ua-mobile": "?0",
13 |             "sec-ch-ua-platform": '"Windows"',
14 |             "Sec-Fetch-Dest": "iframe",
15 |             "Sec-Fetch-Mode": "navigate",
16 |             "Sec-Fetch-Site": "same-origin",
17 |             "Sec-Fetch-User": "?1",
18 |             "Sec-GPC": "1",
19 |             "Upgrade-Insecure-Requests": "1",
20 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
21 |         }
22 | 
23 |     def fetch_sources(self, tmdb_id, season=None, episode=None):
24 |         url = f"https://frembed.fun/player/test.php?id={tmdb_id}"
25 |         response = requests.get(url, headers=self.headers)
26 | 
27 |         if response.status_code == 200:
28 |             m3u8_url = self.extract_m3u8_url(response.text)
29 |             return m3u8_url
30 |         else:
31 |             print("Failed to retrieve content. Status Code:", response.status_code)
32 |             return None
33 | 
34 |     def extract_m3u8_url(self, content):
35 |         pattern = r"src:\s*'([^']*\bmaster\.m3u8\b[^']*)'"
36 |         match = re.search(pattern, content)
37 | 
38 |         if match:
39 |             return {'url': match.group(1), 'source': 'FrEmbed', 'proxy': 'False', 'lang': 'fr', 'type': 'hls'}
40 |         else:
41 |             print("M3U8 URL not found in the response content.")
42 |             return None


--------------------------------------------------------------------------------
/scrapers/filecdn.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import re
 3 | 
 4 | class FileCDNScraper:
 5 |     def scrape_movie(self, tmdb_id):
 6 |         url = f'https://www.filecdn.cloud/e/tmdb{tmdb_id}dub'
 7 |         return {'url': self._scrape(url), 'source': 'FileCDN - Movie', 'proxy': 'False', 'lang': 'pt', 'type': 'mp4'}
 8 | 
 9 | 
10 |     def scrape_tv_show(self, tmdb_id, season, episode):
11 |         url = f'https://www.filecdn.cloud/e/tvtmdb{tmdb_id}t{season}e{episode}dub'
12 |         return {'url': self._scrape(url), 'source': 'FileCDN - TV Show', 'proxy': 'False', 'lang': 'pt', 'type': 'mp4'}
13 | 
14 |     def _scrape(self, url):
15 |         response = requests.get(url)
16 |         if response.status_code == 200:
17 |             iframe_match = re.search(r'<iframe src="(.*?)"', response.text)
18 |             if iframe_match:
19 |                 iframe_source = iframe_match.group(1)
20 |                 return self._get_mp4_url(iframe_source)
21 |             else:
22 |                 print("Could not find iframe source.")
23 |         else:
24 |             print(f"Failed to retrieve content. Status code: {response.status_code}")
25 | 
26 |     def _get_mp4_url(self, iframe_source):
27 |         response = requests.get(iframe_source)
28 |         if response.status_code == 200:
29 |             mp4_match = re.search(r'<source src="(.*?)" type="video/mp4">', response.text)
30 |             if mp4_match:
31 |                 mp4_url = mp4_match.group(1)
32 |                 return mp4_url
33 |             else:
34 |                 print("Could not find MP4 URL.")
35 |         else:
36 |             print(f"Failed to retrieve content. Status code: {response.status_code}")
37 | 
38 | # Example usage:
39 | # scraper = FileCDNScraper()
40 | # movie_url = scraper.scrape_movie(872585)
41 | # print("Movie URL:", movie_url)
42 | 
43 | # tv_show_url = scraper.scrape_tv_show(108978, 1, 1)
44 | # print("TV Show URL:", tv_show_url)
45 | 


--------------------------------------------------------------------------------
/scrapers/extractors/megacloud.py:
--------------------------------------------------------------------------------
 1 | from PIL import Image
 2 | import requests
 3 | import base64
 4 | import io
 5 | 
 6 | class MegaCloud:
 7 |     def __init__(self):
 8 |         self.name = "MegaCloud"
 9 |         self.main_url = "https://megacloud.tv"
10 |         self.lucky_image_url = f"{self.main_url}/images/lucky_animal/icon.png"
11 | 
12 |     def init(self):
13 |         try:
14 |             image_response = requests.get(self.lucky_image_url)
15 |             if image_response.status_code == 200:
16 |                 image = Image.open(io.BytesIO(image_response.content))
17 |                 key = self.extract_real_key(image)
18 |               
19 |                 return list(key)
20 |             else:
21 |                 print("Failed to fetch image. Status code:", image_response.status_code)
22 |                 return None
23 |         except Exception as e:
24 |             print("Error:", e)
25 |             return None
26 | 
27 |     def extract_real_key(self, image):
28 |         width, height = image.size
29 |         pixel_data = []
30 | 
31 |         for y in range(height):
32 |             for x in range(width):
33 |                 pixel = image.getpixel((x, y))
34 |                 pixel_data.extend([int(channel) for channel in pixel])
35 | 
36 |         encoded_byte_array = self.compute_key_from_image(pixel_data)
37 |         return encoded_byte_array
38 | 
39 |     def compute_key_from_image(self, image_data):
40 |         image_chunks = ""
41 |         image_chunks_to_char = ""
42 |         image_chunks_to_char_to_hex = []
43 | 
44 |         for i in range(image_data[3] * 8):
45 |             image_chunks += str(image_data[(i + 1) * 4 + 3] % 2)
46 | 
47 |         image_chunks = image_chunks[:len(image_chunks) - len(image_chunks) % 2]
48 |         for i in range(0, len(image_chunks), 8):
49 |             image_chunks_to_char += chr(int(image_chunks[i:i + 8], 2))
50 | 
51 |         for i in range(0, len(image_chunks_to_char) - 1, 2):
52 |             image_chunks_to_char_to_hex.append(int(image_chunks_to_char[i:i + 2], 16))
53 | 
54 |         key = bytes(image_chunks_to_char_to_hex)
55 |         return key
56 | 
57 | # Usage
58 | # key_extractor = MegaCloud()
59 | # keys = key_extractor.init()
60 | # print(keys)
61 | 


--------------------------------------------------------------------------------
/scrapers/embeds/uqload.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import requests
 3 | 
 4 | class Uqload:
 5 |     def __init__(self, url):
 6 |         self.url = url.replace("uqload.co", "uqload.to")
 7 |         self.domain = "uqload.to"
 8 |         self.headers = {
 9 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
10 |             "Accept-Language": "en-GB,en;q=0.6",
11 |             "Connection": "keep-alive",
12 |             "Host": self.domain,
13 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
14 |             "sec-ch-ua-mobile": "?0",
15 |             "sec-ch-ua-platform": '"Windows"',
16 |             "Sec-Fetch-Dest": "document",
17 |             "Sec-Fetch-Mode": "navigate",
18 |             "Sec-Fetch-Site": "none",
19 |             "Sec-Fetch-User": "?1",
20 |             "Sec-GPC": "1",
21 |             "Upgrade-Insecure-Requests": "1",
22 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
23 |         }
24 | 
25 |     def make_request(self):
26 |         if not self.url.startswith("https://" + self.domain) or not self.url.endswith(".html"):
27 |             print(f"URL must start with 'https://{self.domain}' and end with '.html'")
28 |             return None
29 | 
30 |         try:
31 |             response = requests.get(self.url, headers=self.headers)
32 |             response.raise_for_status()
33 |             print("Response Status Code:", response.status_code)
34 |             return response.text
35 |         except requests.exceptions.RequestException as e:
36 |             print("Error making request:", e)
37 |             return None
38 | 
39 |     def extract_mp4_url(self, html_content):
40 |         mp4_url_pattern = r'(?<=sources: \[")https://[^"]+\.mp4(?="\])'
41 |         match = re.search(mp4_url_pattern, html_content)
42 |         if match:
43 |             return match.group(0)
44 |         else:
45 |             return None
46 | 
47 |     def main(self):
48 |         html_content = self.make_request()
49 |         if html_content:
50 |             mp4_url = self.extract_mp4_url(html_content)
51 |             return mp4_url
52 |         else:
53 |             return None
54 | 
55 | # uqload = Uqload("https://uqload.to/embed-j8u0gyunkxdb.html")
56 | # mp4_url = uqload.main()
57 | # print(mp4_url)


--------------------------------------------------------------------------------
/scrapers/embeds/voe.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import requests
 3 | 
 4 | class Voe:
 5 |     def __init__(self, url):
 6 |         self.url = url.replace("voe.sx", "brookethoughi.com")
 7 |         self.domain = "brookethoughi.com"
 8 |         self.headers = {
 9 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
10 |             "Accept-Language": "en-GB,en;q=0.6",
11 |             "Connection": "keep-alive",
12 |             "Host": self.domain,
13 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
14 |             "sec-ch-ua-mobile": "?0",
15 |             "sec-ch-ua-platform": '"Windows"',
16 |             "Sec-Fetch-Dest": "document",
17 |             "Sec-Fetch-Mode": "navigate",
18 |             "Sec-Fetch-Site": "none",
19 |             "Sec-Fetch-User": "?1",
20 |             "Sec-GPC": "1",
21 |             "Upgrade-Insecure-Requests": "1",
22 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
23 |         }
24 | 
25 |     def make_request(self):
26 |         if not self.url.startswith("https://" + self.domain + "/e/"):
27 |             print(f"URL must start with 'https://{self.domain}/e/'")
28 |             return None
29 | 
30 |         try:
31 |             response = requests.get(self.url, headers=self.headers)
32 |             response.raise_for_status()
33 |             print("Response Status Code:", response.status_code)
34 |             return response.text
35 |         except requests.exceptions.RequestException as e:
36 |             print("Error making request:", e)
37 |             return None
38 | 
39 |     def extract_mp4_url(self, html_content):
40 |         regex_pattern = r"'hls': '([^']+)'"
41 |         match = re.search(regex_pattern, html_content)
42 | 
43 |         if match:
44 |             extracted_url = match.group(1)
45 |             return extracted_url
46 |         else:
47 |             return None
48 | 
49 |     def main(self):
50 |         html_content = self.make_request()
51 |         if html_content:
52 |             mp4_url = self.extract_mp4_url(html_content)
53 |             return mp4_url
54 |         else:
55 |             return None
56 |             
57 | # Example usage:
58 | # voe = Voe("https://voe.sx/e/qsci3b0zpz2i")
59 | # hls_url = voe.main()
60 | # print(hls_url)


--------------------------------------------------------------------------------
/scrapers/subtitles.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | from bs4 import BeautifulSoup
 3 | import time
 4 | 
 5 | def get_subtitles(tmdb_id, season=None, episode=None):
 6 |     start_time = time.time()  # Record the start time
 7 | 
 8 |     base_url = "https://vidsrc.to/embed/"
 9 | 
10 |     headers = {
11 |         "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
12 |         "accept-language": "en-GB,en;q=0.9",
13 |         "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
14 |         "sec-ch-ua-mobile": "?1",
15 |         "sec-ch-ua-platform": "\"Android\"",
16 |         "sec-fetch-dest": "document",
17 |         "sec-fetch-mode": "navigate",
18 |         "sec-fetch-site": "none",
19 |         "sec-fetch-user": "?1",
20 |         "sec-gpc": "1",
21 |         "upgrade-insecure-requests": "1"
22 |     }
23 | 
24 |     try:
25 |         url = f"{base_url}tv/{tmdb_id}/{season}/{episode}" if season and episode else f"{base_url}movie/{tmdb_id}"
26 | 
27 |         response = requests.get(url, headers=headers)
28 |         response.raise_for_status()
29 | 
30 |         soup = BeautifulSoup(response.text, 'html.parser')
31 | 
32 |         # Find the <a> element within the <li> element under the 'episodes' class
33 |         a_element = soup.select_one('.episodes li a')
34 | 
35 |         # Extract the data-id attribute value
36 |         if a_element:
37 |             data_id = a_element.get('data-id')
38 |             print(f"data-id value: {data_id}")
39 | 
40 |             # Send request to subtitles endpoint
41 |             subtitles_url = f"https://vidsrc.to/ajax/embed/episode/{data_id}/subtitles"
42 |             subtitles_response = requests.get(subtitles_url)
43 |             subtitles_response.raise_for_status()
44 | 
45 |             subtitles_data = subtitles_response.json()
46 | 
47 |             end_time = time.time()  # Record the end time
48 |             elapsed_time = end_time - start_time
49 |             print(f"Fetching subtitles took {elapsed_time:.4f} seconds")
50 | 
51 |             return subtitles_data
52 | 
53 |         else:
54 |             print("Could not find the data-id attribute")
55 |             return []
56 | 
57 |     except requests.exceptions.RequestException as e:
58 |         print(f"Error making the request: {e}")
59 |         return []
60 |     except Exception as e:
61 |         print(f"An unexpected error occurred: {e}")
62 |         return []
63 | 


--------------------------------------------------------------------------------
/scrapers/embeds/upstream.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import requests
 3 | from scrapers.utils.unpacker import detect, unpack
 4 | 
 5 | 
 6 | class Upstream:
 7 |     def __init__(self, url):
 8 |         self.url = url
 9 |         self.domain = "upstream.to"
10 |         self.headers = {
11 |             "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
12 |             "accept-language": "en-GB,en;q=0.9",
13 |             "cache-control": "no-cache",
14 |             "pragma": "no-cache",
15 |             "sec-ch-ua": "\"Brave\";v=\"123\", \"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"123\"",
16 |             "sec-ch-ua-mobile": "?1",
17 |             "sec-ch-ua-platform": "\"Android\"",
18 |             "sec-fetch-dest": "document",
19 |             "sec-fetch-mode": "navigate",
20 |             "sec-fetch-site": "none",
21 |             "sec-fetch-user": "?1",
22 |             "sec-gpc": "1",
23 |             "upgrade-insecure-requests": "1",
24 |         }
25 | 
26 |     def make_request(self):
27 |         if not self.url.startswith("https://" + self.domain + "/embed"):
28 |             print(f"URL must start with 'https://{self.domain}/embe'")
29 |             return None
30 | 
31 |         try:
32 |             response = requests.get(self.url, headers=self.headers)
33 |             response.raise_for_status()
34 |             print("Response Status Code:", response.status_code)
35 |             return response.text
36 |         except requests.exceptions.RequestException as e:
37 |             print("Error making request:", e)
38 |             return None
39 | 
40 |   
41 |   
42 |     def extract_source_url(self, input_string):
43 |         pattern = r'sources:\[\{file:"(.*?)"\}\]'
44 |         match = re.search(pattern, input_string)
45 |         if match:
46 |             return match.group(1)
47 |         else:
48 |             return None
49 |         
50 |     def unpack_html(self, html_content):
51 |         if detect(html_content):
52 |           print("Detected")
53 |           unpacked = unpack(html_content)
54 |           return self.extract_source_url(unpacked) 
55 |         return None
56 | 
57 |     def main(self):
58 |         html_content = self.make_request()
59 |         if html_content:
60 |             hls = self.unpack_html(html_content)
61 |             return hls
62 |         else:
63 |             return None
64 | 
65 | # Example usage:
66 | # upstream = Upstream("https://upstream.to/embed-wzkr7jkwl45f.html")
67 | # url = upstream.main()
68 | # print(url)
69 | 
70 | 


--------------------------------------------------------------------------------
/scrapers/streamium.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import re
 3 | 
 4 | class Streamium:
 5 |     def __init__(self, api_key):
 6 |         self.api_key = api_key
 7 |         self.headers = {
 8 |             "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 9 |             "accept-language": "en-GB,en;q=0.8",
10 |             "cache-control": "max-age=0",
11 |             "if-modified-since": "Wed, 13 Mar 2024 21:16:23 GMT",
12 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
13 |             "sec-ch-ua-mobile": "?1",
14 |             "sec-ch-ua-platform": "\"Android\"",
15 |             "sec-fetch-dest": "document",
16 |             "sec-fetch-mode": "navigate",
17 |             "sec-fetch-site": "same-origin",
18 |             "sec-fetch-user": "?1",
19 |             "sec-gpc": "1",
20 |             "upgrade-insecure-requests": "1",
21 |             "Referer": f"https://streamium.st/",
22 |             "Referrer-Policy": "strict-origin-when-cross-origin"
23 |         }
24 |       
25 |     def extract_video_src(self, html_content):
26 |         pattern = r'<source\s+src="([^"]+)"\s+type="video/mp4">'
27 |         match = re.search(pattern, html_content)
28 |         if match:
29 |             return match.group(1)
30 |         else:
31 |             return None
32 | 
33 |     def get_imdb_id(self, tmdb_id, media_type):
34 |         url = f"https://api.themoviedb.org/3/{media_type}/{tmdb_id}/external_ids?api_key={self.api_key}"
35 |         response = requests.get(url, headers=self.headers)
36 |         data = response.json()
37 |         return data.get("imdb_id")
38 | 
39 |     def fetch_response_text(self, imdb_id, media_type, season="", episode=""):
40 |         if media_type == "movie":
41 |             url = f"https://s1.goquick.st/play/{imdb_id}/Road%20House"
42 |         elif media_type == "tv":
43 |             url = f"https://s1.goquick.st/play/{imdb_id}/Road%20House?season={season}&episode={episode}"
44 |         else:
45 |             return None
46 | 
47 |         response = requests.get(url, headers=self.headers)
48 |         if response.status_code == 200:
49 |             return response.text
50 |         else:
51 |             return None
52 | 
53 |     def fetch_sources(self, tmdb_id, media_type="movie", season="", episode=""):
54 |         imdb_id = self.get_imdb_id(tmdb_id, media_type) # TODO - Fix TV Shows (they use imdb season ids, not show ids)
55 |         if imdb_id:
56 |             resp_text = self.fetch_response_text(imdb_id, media_type, season, episode)
57 |             if resp_text:
58 |                 video_src = self.extract_video_src(resp_text)
59 |                 if video_src:
60 |                     return {'url': f"https://s1.goquick.st{video_src}#.mp4", 'source': 'Streamium', 'proxy': 'False', 'lang': 'en', 'type': 'mp4'}
61 |         return None
62 | 
63 | 
64 | # Example usage:
65 | # api_key = "f1dd7f2494de60ef4946ea81fd5ebaba"
66 | # scraper = Streamium(api_key)
67 | # response_data = scraper.fetch_sources(tmdb_id="108978", media_type="movie")
68 | # print(f"URL: {response_data}")


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
  1 | aiohttp==3.9.3
  2 | aiosignal==1.3.1
  3 | anyio==4.2.0
  4 | argon2-cffi==23.1.0
  5 | argon2-cffi-bindings==21.2.0
  6 | arrow==1.3.0
  7 | asgiref==3.7.2
  8 | asttokens==2.4.1
  9 | async-lru==2.0.4
 10 | async-timeout==4.0.3
 11 | attrs==23.2.0
 12 | Babel==2.14.0
 13 | beautifulsoup4==4.12.3
 14 | bleach==6.1.0
 15 | blinker==1.7.0
 16 | certifi==2024.2.2
 17 | cffi==1.16.0
 18 | charset-normalizer==3.3.2
 19 | click==8.1.7
 20 | cloudscraper==1.2.71
 21 | colorama==0.4.6
 22 | comm==0.2.1
 23 | contourpy==1.2.0
 24 | cycler==0.12.1
 25 | debugpy==1.8.0
 26 | decorator==5.1.1
 27 | defusedxml==0.7.1
 28 | exceptiongroup==1.2.0
 29 | executing==2.0.1
 30 | fastjsonschema==2.19.1
 31 | filelock==3.13.1
 32 | Flask==3.0.2
 33 | Flask-Cors==4.0.0
 34 | fonttools==4.48.1
 35 | fqdn==1.5.1
 36 | frozenlist==1.4.1
 37 | fsspec==2024.2.0
 38 | gitdb==4.0.11
 39 | GitPython==3.1.41
 40 | h11==0.14.0
 41 | httpcore==1.0.2
 42 | httpx==0.26.0
 43 | idna==3.6
 44 | ipykernel==6.29.1
 45 | ipython==8.21.0
 46 | isoduration==20.11.0
 47 | itsdangerous==2.1.2
 48 | jedi==0.19.1
 49 | Jinja2==3.1.3
 50 | joblib==1.3.2
 51 | json5==0.9.14
 52 | jsonpointer==2.4
 53 | jsonschema==4.21.1
 54 | jsonschema-specifications==2023.12.1
 55 | jupyter-events==0.9.0
 56 | jupyter-lsp==2.2.2
 57 | jupyter-server-mathjax==0.2.6
 58 | jupyter_client==8.6.0
 59 | jupyter_core==5.7.1
 60 | jupyter_server==2.12.5
 61 | jupyter_server_terminals==0.5.2
 62 | jupyterlab==4.1.0
 63 | jupyterlab_git==0.50.0
 64 | jupyterlab_pygments==0.3.0
 65 | jupyterlab_server==2.25.2
 66 | kiwisolver==1.4.5
 67 | MarkupSafe==2.1.5
 68 | matplotlib==3.8.2
 69 | matplotlib-inline==0.1.6
 70 | mistune==3.0.2
 71 | mpmath==1.3.0
 72 | multidict==6.0.5
 73 | nbclient==0.9.0
 74 | nbconvert==7.15.0
 75 | nbdime==4.0.1
 76 | nbformat==5.9.2
 77 | nest-asyncio==1.6.0
 78 | networkx==3.2.1
 79 | notebook_shim==0.2.3
 80 | numpy==1.26.4
 81 | nvidia-cublas-cu12==12.1.3.1
 82 | nvidia-cuda-cupti-cu12==12.1.105
 83 | nvidia-cuda-nvrtc-cu12==12.1.105
 84 | nvidia-cuda-runtime-cu12==12.1.105
 85 | nvidia-cudnn-cu12==8.9.2.26
 86 | nvidia-cufft-cu12==11.0.2.54
 87 | nvidia-curand-cu12==10.3.2.106
 88 | nvidia-cusolver-cu12==11.4.5.107
 89 | nvidia-cusparse-cu12==12.1.0.106
 90 | nvidia-nccl-cu12==2.19.3
 91 | nvidia-nvjitlink-cu12==12.3.101
 92 | nvidia-nvtx-cu12==12.1.105
 93 | overrides==7.7.0
 94 | packaging==23.2
 95 | pandas==2.2.0
 96 | pandocfilters==1.5.1
 97 | parso==0.8.3
 98 | pexpect==4.9.0
 99 | pillow==10.2.0
100 | platformdirs==4.2.0
101 | plotly==5.18.0
102 | prometheus-client==0.19.0
103 | prompt-toolkit==3.0.43
104 | psutil==5.9.8
105 | ptyprocess==0.7.0
106 | pure-eval==0.2.2
107 | pycparser==2.21
108 | Pygments==2.17.2
109 | pyparsing==3.1.1
110 | python-dateutil==2.8.2
111 | python-json-logger==2.0.7
112 | pytz==2024.1
113 | PyYAML==6.0.1
114 | pyzmq==25.1.2
115 | referencing==0.33.0
116 | requests==2.31.0
117 | requests-toolbelt==1.0.0
118 | rfc3339-validator==0.1.4
119 | rfc3986-validator==0.1.1
120 | rpds-py==0.17.1
121 | scikit-learn==1.4.0
122 | scipy==1.12.0
123 | seaborn==0.13.2
124 | Send2Trash==1.8.2
125 | six==1.16.0
126 | smmap==5.0.1
127 | sniffio==1.3.0
128 | soupsieve==2.5
129 | stack-data==0.6.3
130 | sympy==1.12
131 | tenacity==8.2.3
132 | terminado==0.18.0
133 | threadpoolctl==3.2.0
134 | tinycss2==1.2.1
135 | tomli==2.0.1
136 | torch==2.2.0
137 | tornado==6.4
138 | traitlets==5.14.1
139 | triton==2.2.0
140 | types-python-dateutil==2.8.19.20240106
141 | typing_extensions==4.9.0
142 | tzdata==2023.4
143 | uri-template==1.3.0
144 | urllib3==2.0.7
145 | wcwidth==0.2.13
146 | webcolors==1.13
147 | webencodings==0.5.1
148 | websocket-client==1.7.0
149 | Werkzeug==3.0.1
150 | yarl==1.9.4
151 | 


--------------------------------------------------------------------------------
/scrapers/showflix.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | from scrapers.embeds.streamwish import Streamwish
 3 | 
 4 | class Showflix:
 5 |     def __init__(self):
 6 |         self.headers = {
 7 |             "Accept": "*/*",
 8 |             "Accept-Language": "en-GB,en;q=0.9",
 9 |             "Connection": "keep-alive",
10 |             "Content-Length": "257",
11 |             "Content-Type": "text/plain",
12 |             "Host": "parse.showflix.online",
13 |             "Origin": "https://showflix.lol",
14 |             "Referer": "https://showflix.lol/",
15 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
16 |             "sec-ch-ua-mobile": "?0",
17 |             "sec-ch-ua-platform": '"Windows"',
18 |             "Sec-Fetch-Dest": "empty",
19 |             "Sec-Fetch-Mode": "cors",
20 |             "Sec-Fetch-Site": "cross-site",
21 |             "Sec-GPC": "1",
22 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
23 |         }
24 | 
25 |         self.url = "https://parse.showflix.online/parse/classes/movies"
26 | 
27 |     def fetch_sources(self, movie_name, user_ip):
28 |         data = {
29 |             "where": {
30 |                 "movieName": {
31 |                     "$regex": movie_name,
32 |                     "$options": "i"
33 |                 }
34 |             },
35 |             "order": "-updatedAt",
36 |             "_method": "GET",
37 |             "_ApplicationId": "SHOWFLIXAPPID",
38 |             "_JavaScriptKey": "SHOWFLIXMASTERKEY",
39 |             "_ClientVersion": "js3.4.1",
40 |             "_InstallationId": "869613b0-4a8f-4a62-a8d1-6ed5e0282f1a"
41 |         }
42 | 
43 |         try:
44 |             response = requests.post(self.url, json=data, headers=self.headers)
45 |             response.raise_for_status()  # Raise an error for bad response status codes
46 |             json_data = response.json()
47 | 
48 |             if 'results' in json_data and len(json_data['results']) > 0:
49 |                 first_result = json_data['results'][0]
50 |                 streaming_ids = {
51 |                     "streamlink": first_result.get("streamlink"),
52 |                     "language": first_result.get("language"),
53 |                     "hdlink": first_result.get("hdlink"),
54 |                     "sharedisk": first_result.get("sharedisk"),
55 |                     "streamhide": first_result.get("streamhide"),
56 |                     "streamwish": first_result.get("streamwish"),
57 |                     "filelions": first_result.get("filelions"),
58 |                     "streamruby": first_result.get("streamruby"),
59 |                     "uploadever": first_result.get("uploadever")
60 |                 }
61 | 
62 |                 # Ensure streamwish key is not None before accessing it
63 |                 if streaming_ids.get('streamwish'):
64 |                     showflix = Streamwish(f"https://embedwish.com/e/{streaming_ids['streamwish']}.html", user_ip)
65 |                     hls_url = showflix.main()
66 |                     return {'url': hls_url, 'source': 'ShowFlix', 'proxy': 'True', 'lang': streaming_ids['language'], 'type': 'hls'}
67 |                 else:
68 |                     return "Streamwish link not found."
69 |             else:
70 |                 return "Movie not found."
71 |         except requests.exceptions.RequestException as e:
72 |             print("Error fetching movie source:", e)
73 |             return None
74 | 
75 | # Example usage:
76 | # scraper = Showflix()
77 | # movie_name = "Captain Miller"
78 | # response_data = scraper.fetch_sources(movie_name)
79 | # print(f"Movie URL: {response_data}")
80 | 


--------------------------------------------------------------------------------
/scrapers/unfinished/vidsrcme.py:
--------------------------------------------------------------------------------
  1 | # File yeeted from Ciarands Vidsrcme extractor
  2 | 
  3 | import re
  4 | import requests
  5 | 
  6 | from typing import Optional, Dict
  7 | import base64
  8 | 
  9 | class Utilities:
 10 |     @staticmethod
 11 |     def decode_src(encoded, seed) -> str:
 12 |         encoded_buffer = bytes.fromhex(encoded)
 13 |         decoded = ""
 14 |         for i in range(len(encoded_buffer)):
 15 |             decoded += chr(encoded_buffer[i] ^ ord(seed[i % len(seed)]))
 16 |         return decoded
 17 | 
 18 |     @staticmethod
 19 |     def hunter(h, u, n, t, e, r) -> str:
 20 |         def hunter_def(d, e, f) -> int:
 21 |             charset = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/"
 22 |             source_base = charset[0:e]
 23 |             target_base = charset[0:f]
 24 | 
 25 |             reversed_input = list(d)[::-1]
 26 |             result = 0
 27 | 
 28 |             for power, digit in enumerate(reversed_input):
 29 |                 if digit in source_base:
 30 |                     result += source_base.index(digit) * e**power
 31 | 
 32 |             converted_result = ""
 33 |             while result > 0:
 34 |                 converted_result = target_base[result % f] + converted_result
 35 |                 result = (result - (result % f)) // f
 36 | 
 37 |             return int(converted_result) or 0
 38 |         
 39 |         i = 0
 40 |         result_str = ""
 41 |         while i < len(h):
 42 |             j = 0
 43 |             s = ""
 44 |             while h[i] != n[e]:
 45 |                 s += h[i]
 46 |                 i += 1
 47 | 
 48 |             while j < len(n):
 49 |                 s = s.replace(n[j], str(j))
 50 |                 j += 1
 51 | 
 52 |             result_str += chr(hunter_def(s, e, 10) - t)
 53 |             i += 1
 54 | 
 55 |         return result_str
 56 | 
 57 |     @staticmethod
 58 |     def decode_base64_url_safe(s: str) -> bytearray:
 59 |         standardized_input = s.replace('_', '/').replace('-', '+')
 60 |         binary_data = base64.b64decode(standardized_input)
 61 |         return bytearray(binary_data)
 62 | 
 63 |         
 64 | class VidsrcStreamExtractor:
 65 |     @staticmethod
 66 |     def decode_hls_url(encoded_url: str) -> str:
 67 |         def format_hls_b64(data: str) -> str:
 68 |             encoded_b64 = re.sub(r"\/@#@\/[^=\/]+==", "", data)
 69 |             if re.search(r"\/@#@\/[^=\/]+==", encoded_b64):
 70 |                 return format_hls_b64(encoded_b64)
 71 |             return encoded_b64
 72 | 
 73 |         formatted_b64 = format_hls_b64(encoded_url[2:])
 74 |         b64_data = Utilities.decode_base64_url_safe(formatted_b64)
 75 |         return b64_data.decode("utf-8")
 76 | 
 77 |     def resolve_source(self, **kwargs) -> Optional[Dict]:
 78 |         req = requests.get(kwargs.get("url"), headers={"Referer": kwargs.get("referrer")})
 79 |         if req.status_code != 200:
 80 |             print(f"[VidsrcStreamExtractor] Failed to retrieve media, status code: {req.status_code}...")
 81 |             return None
 82 |         
 83 |         encoded_hls_url = re.search(r'file:"([^"]*)"', req.text)
 84 |         hls_password_url = re.search(r'var pass_path = "(.*?)";', req.text)
 85 | 
 86 |         if not encoded_hls_url or not hls_password_url:
 87 |             print("[VidsrcStreamExtractor] Failed to extract hls or password url...")
 88 |             return None
 89 |         
 90 |         hls_password_url = hls_password_url.group(1)
 91 |         if hls_password_url.startswith("//"):
 92 |             hls_password_url = f"https:{hls_password_url}"
 93 | 
 94 |         hls_url = self.decode_hls_url(encoded_hls_url.group(1))
 95 |         requests.get(hls_password_url, headers={"Referer": kwargs.get("referrer")}) # 26/01/2024 - this isnt necessary, also actual source calls this continuously
 96 | 
 97 |         return {
 98 |             "streams": [hls_url],
 99 |             "subtitles": {}
100 |         }


--------------------------------------------------------------------------------
/scrapers/downloads.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | from bs4 import BeautifulSoup
 3 | 
 4 | class Downloads:
 5 |     def __init__(self):
 6 |         self.headers = {
 7 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 8 |             "Accept-Language": "en-GB,en;q=0.9",
 9 |             "Connection": "keep-alive",
10 |             "Host": "vadapav.mov",
11 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
12 |             "sec-ch-ua-mobile": "?0",
13 |             "sec-ch-ua-platform": "\"Windows\"",
14 |             "Sec-Fetch-Dest": "document",
15 |             "Sec-Fetch-Mode": "navigate",
16 |             "Sec-Fetch-Site": "none",
17 |             "Sec-Fetch-User": "?1",
18 |             "Sec-GPC": "1",
19 |             "Upgrade-Insecure-Requests": "1",
20 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
21 |         }
22 |         self.base_url = "https://vadapav.mov"
23 | 
24 |     def fetch_download_info(self, url):
25 |         response = requests.get(url, headers=self.headers)
26 |         if response.status_code == 200:
27 |             response_text = response.text
28 |         else:
29 |             return None, None
30 | 
31 |         soup = BeautifulSoup(response_text, 'html.parser')
32 |         file_entries = soup.find_all('a', class_='file-entry wrap', href=True)
33 | 
34 |         for file_entry in file_entries:
35 |             href = file_entry['href']
36 |             file_name = file_entry.text
37 |             if file_name.endswith('.mp4') or file_name.endswith('.mkv'):
38 |                 download_url = f'{self.base_url}{href}'
39 |                 return file_name, download_url
40 |         return None, None
41 | 
42 |     def fetch_data(self, name, year):
43 |         url = f"{self.base_url}/s/{name} ({year})"
44 |         headers = {
45 |             "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
46 |             "accept-language": "en-GB,en;q=0.8",
47 |             "cache-control": "max-age=0",
48 |             "if-modified-since": "Wed, 13 Mar 2024 21:16:23 GMT",
49 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
50 |             "sec-ch-ua-mobile": "?1",
51 |             "sec-ch-ua-platform": "\"Android\"",
52 |             "sec-fetch-dest": "document",
53 |             "sec-fetch-mode": "navigate",
54 |             "sec-fetch-site": "same-origin",
55 |             "sec-fetch-user": "?1",
56 |             "sec-gpc": "1",
57 |             "upgrade-insecure-requests": "1",
58 |             "Referer": f"{self.base_url}/",
59 |             "Referrer-Policy": "strict-origin-when-cross-origin"
60 |         }
61 |         response = requests.get(url, headers=headers)
62 | 
63 |         if response.status_code == 200:
64 |             return response.text
65 |         else:
66 |             return None
67 | 
68 |     def scrape_movies(self, name, year):
69 |         data = self.fetch_data(name, year)
70 |         if data:
71 |             soup = BeautifulSoup(data, 'html.parser')
72 |             movie_list = []
73 | 
74 |             for div in soup.find_all('div', class_='centerflex name-div'):
75 |                 link = div.find('a')['href']
76 |                 movie_name = div.find('a', class_='directory-entry wrap').text
77 |                 movie_list.append({'name': movie_name, 'link': link})
78 | 
79 |             movie_info_list = []
80 |             for movie in movie_list:
81 |                 file_name, download_url = self.fetch_download_info(f"{self.base_url}{movie['link']}")
82 |                 if file_name and download_url:
83 |                     movie_info_list.append({'file_name': file_name, 'download_url': download_url})
84 | 
85 |             return movie_info_list
86 |         else:
87 |             return None


--------------------------------------------------------------------------------
/scrapers/twoembed.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | from bs4 import BeautifulSoup
  3 | import re
  4 | 
  5 | class TwoEmbed:
  6 |     def __init__(self):
  7 |         self.session = requests.Session()
  8 |         self.base_url = "https://uqloads.xyz/e/"
  9 | 
 10 |         self.default_headers = {
 11 |             "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 12 |             "accept-language": "en-GB,en;q=0.9",
 13 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
 14 |             'Connection': 'keep-alive',
 15 |             'Cookie': '_ym_uid=1709594704938985430; _ym_d=1709594704; _ym_isad=2',
 16 |             'Host': 'uqloads.xyz',
 17 |             'Referer': 'https://streamsrcs.2embed.cc/',
 18 |             'sec-ch-ua-mobile': '?0',
 19 |             'sec-ch-ua-platform': '"Windows"',
 20 |             'Sec-Fetch-Dest': 'iframe',
 21 |             'Sec-Fetch-Mode': 'navigate',
 22 |             'Sec-Fetch-Site': 'cross-site',
 23 |             'Sec-Fetch-User': '?1',
 24 |             'Sec-GPC': '1',
 25 |             'Upgrade-Insecure-Requests': '1',
 26 |             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36'
 27 |         }
 28 | 
 29 |     def fetch_content_with_id(self, video_id, user_ip):
 30 |         url = f"{self.base_url}{video_id}"
 31 |         try:
 32 |             headers = {
 33 |                 "X-Forwarded-For": user_ip
 34 |             }
 35 |             headers.update(self.default_headers)
 36 |             response = self.session.get(url, headers=headers)
 37 |             response.raise_for_status()
 38 |             return response.text
 39 |         except requests.exceptions.RequestException as e:
 40 |             print(f"Error: {e}")
 41 |             return None
 42 | 
 43 |     def tmdb_to_imdb(self, tmdb_id):
 44 |         tmdb_api_key = "f1dd7f2494de60ef4946ea81fd5ebaba"
 45 |         tmdb_url = f"https://api.themoviedb.org/3/movie/{tmdb_id}?api_key={tmdb_api_key}"
 46 | 
 47 |         try:
 48 |             response = requests.get(tmdb_url)
 49 |             response.raise_for_status()
 50 |             data = response.json()
 51 |             imdb_id = data.get('imdb_id')
 52 |             return imdb_id
 53 |         except requests.exceptions.RequestException as e:
 54 |             print(f"Error fetching IMDb ID from TMDB: {e}")
 55 |             return None
 56 | 
 57 |     def fetch_sources(self, tmdb_id, user_ip, season=None, episode=None):
 58 |         imdb_id = self.tmdb_to_imdb(tmdb_id)
 59 | 
 60 |         if imdb_id:
 61 |             url = f"https://1hd.store/embed/{imdb_id}"
 62 | 
 63 |             headers = {
 64 |                 "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 65 |                 "accept-language": "en-GB,en;q=0.9",
 66 |                 "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
 67 |                 'Connection': 'keep-alive',
 68 |                 'Host': '1hd.store',
 69 |                 'Referer': f'https://1hd.store/watch-the-marvels-2023-online-{tmdb_id}', # why not its not like they check lmao
 70 |                 'sec-ch-ua': '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
 71 |                 'sec-ch-ua-mobile': '?0',
 72 |                 'sec-ch-ua-platform': '"Windows"',
 73 |                 'Sec-Fetch-Dest': 'iframe',
 74 |                 'Sec-Fetch-Mode': 'navigate',
 75 |                 'Sec-Fetch-Site': 'same-origin',
 76 |                 'Sec-GPC': '1',
 77 |                 'Upgrade-Insecure-Requests': '1',
 78 |                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36'
 79 |             }
 80 | 
 81 |             try:
 82 |                 response = self.session.get(url, headers=headers)
 83 |                 response.raise_for_status()
 84 |                 soup = BeautifulSoup(response.content, 'html.parser')
 85 |                 urls = [div['onclick'].split("'")[1] for div in soup.find_all('div', class_='btn-iframe')]
 86 |                 stripped_urls = [url.replace('https://streamsrcs.2embed.cc/swish-autostream?id=', '') for url in urls]
 87 | 
 88 |                 if stripped_urls:
 89 |                     uqcloud_content = self.fetch_content_with_id(stripped_urls[0], user_ip)
 90 |                     m3u8_urls = re.findall(r'file:\s*"([^"]+)"', uqcloud_content)
 91 | 
 92 |                     if m3u8_urls:
 93 |                         return {'url': m3u8_urls[0], 'source': '2Embed', 'proxy': 'False', 'lang': 'en', 'type': 'hls'}
 94 | 
 95 |                     else:
 96 |                         print("M3U8 URL not found in the response.")
 97 |                 else:
 98 |                     print("No URLs found in the response.")
 99 |             except requests.exceptions.RequestException as e:
100 |                 print(f"Error: {e}")
101 |             return None
102 | 


--------------------------------------------------------------------------------
/scrapers/embeds/dood.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | import re
  3 | import random
  4 | import string
  5 | import time
  6 | 
  7 | class Doodstream:
  8 |     def __init__(self, doodstream_url, my_ip):
  9 |         self.doodstream_url = doodstream_url
 10 |         self.url = f"https://d0000d.com/e/{doodstream_url.split('/e/')[1]}"
 11 |         self.my_ip = my_ip
 12 | 
 13 |         self.base_headers = {
 14 |             "Host": "d0000d.com",
 15 |             "Connection": "keep-alive",
 16 |             "sec-ch-ua": "\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"",
 17 |             "DNT": "1",
 18 |             "sec-ch-ua-mobile": "?0",
 19 |             "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
 20 |             "sec-ch-ua-platform": "\"macOS\"",
 21 |             "Accept": "*/*",
 22 |             "Sec-Fetch-Site": "cross-site",
 23 |             "Sec-Fetch-Mode": "no-cors",
 24 |             "Sec-Fetch-Dest": "video",
 25 |             "Referer": self.url,
 26 |             "Accept-Language": "en-US,en;q=0.9,ar;q=0.8",
 27 |             "Pragma": "no-cache",
 28 |             "Cache-Control": "no-cache",
 29 |             "X-Requested-With": "XMLHttpRequest",
 30 |             "X-Forwarded-For": self.my_ip
 31 |         }
 32 | 
 33 |         self.md5_headers = {
 34 |             'Accept': '*/*',
 35 |             'Accept-Language': 'en-GB,en;q=0.6',
 36 |             'Cache-Control': 'no-cache',
 37 |             'Connection': 'keep-alive',
 38 |             'Cookie': 'lang=1',
 39 |             'Host': 'd0000d.com',
 40 |             'Pragma': 'no-cache',
 41 |             'Referer': self.url,
 42 |             'sec-ch-ua': '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
 43 |             'sec-ch-ua-mobile': '?0',
 44 |             'sec-ch-ua-platform': '"Windows"',
 45 |             'Sec-Fetch-Dest': 'empty',
 46 |             'Sec-Fetch-Mode': 'cors',
 47 |             'Sec-Fetch-Site': 'same-origin',
 48 |             'Sec-GPC': '1',
 49 |             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
 50 |             'X-Requested-With': 'XMLHttpRequest',
 51 |             "X-Forwarded-For": self.my_ip,
 52 |         }
 53 | 
 54 |     def generate_random_string(self, length):
 55 |         characters = string.ascii_letters + string.digits
 56 |         return ''.join(random.choice(characters) for _ in range(length))
 57 | 
 58 |     def solve_captcha(self):
 59 |         endpoint = "https://turn.seized.live/solve"
 60 |         headers = {"Content-Type": "application/json"}
 61 |         data = {"sitekey": "0x4AAAAAAALn0BYsCrtFUbm_", "invisible": True, "url": self.url}
 62 | 
 63 |         try:
 64 |             response = requests.post(endpoint, json=data, headers=headers)
 65 | 
 66 |             if response.status_code == 200:
 67 |                 print(f"captcha solved: {response.json()}")
 68 |                 verify = self.validate_captcha(response.json()["token"])
 69 |                 return response.json()
 70 |             else:
 71 |                 print(f"Error: {response.status_code}, {response.text}")
 72 |         except Exception as e:
 73 |             print(f"Error: {e}")
 74 | 
 75 |         return None
 76 | 
 77 |     def validate_captcha(self, token):
 78 |         headers = self.base_headers.copy()
 79 |         response = requests.get(f"https://d0000d.com/dood?op=validate&gc_response={token}", headers=headers)
 80 |         return response.text
 81 | 
 82 |     def extract_md5_url(self, html_response):
 83 |         match = re.search(r"\$\.get\('\/pass_md5([^']+)", html_response)
 84 |         return match.group().replace("$.get('", "") if match else None
 85 | 
 86 |     def get_data_for_later(self, html_response):
 87 |         data_for_later = re.search(r'\?token=([^&]+)&expiry=', html_response)
 88 |         return data_for_later.group(1) if data_for_later else None
 89 | 
 90 |     def main(self):
 91 |         response = requests.get(f"{self.url}", headers=self.base_headers)
 92 |         html_response = response.text
 93 |         print("extracting md5 url")
 94 |         md5_url = self.extract_md5_url(html_response)
 95 |   
 96 |         if md5_url is None:
 97 |             print("solving captcha")
 98 |             html_response = self.solve_captcha()
 99 |             response = requests.get(f"{self.url}", headers=self.base_headers)
100 |             html_response = response.text
101 |             md5_url = self.extract_md5_url(html_response)
102 | 
103 |             if md5_url is None:
104 |                 exit()
105 |               
106 |         print("md5 extracted")
107 |         data_for_later = self.get_data_for_later(html_response)
108 | 
109 |         md5_url = f"https://d0000d.com{md5_url}"
110 | 
111 |         response = requests.get(f"{md5_url}", headers=self.md5_headers)
112 |         expiry_timestamp = int(time.time() * 1000)
113 | 
114 |         constructed_url = f"{response.text}{self.generate_random_string(10)}?token={data_for_later}&expiry={expiry_timestamp}#.mp4"
115 |         # print(constructed_url)
116 |         return constructed_url
117 | 


--------------------------------------------------------------------------------
/scrapers/utils/unpacker.py:
--------------------------------------------------------------------------------
  1 | #
  2 | # Unpacker for Dean Edward's p.a.c.k.e.r, a part of javascript beautifier
  3 | # by Einar Lielmanis <einar@beautifier.io>
  4 | #
  5 | #     written by Stefano Sanfilippo <a.little.coder@gmail.com>
  6 | 
  7 | 
  8 | """Unpacker for Dean Edward's p.a.c.k.e.r"""
  9 | 
 10 | import re
 11 | import string
 12 | import sys
 13 | 
 14 | PRIORITY = 1
 15 | 
 16 | class PackerError(Exception):
 17 |   pass
 18 |   
 19 | def detect(source):
 20 |     global beginstr
 21 |     global endstr
 22 |     beginstr = ""
 23 |     endstr = ""
 24 |     begin_offset = -1
 25 |     """Detects whether `source` is P.A.C.K.E.R. coded."""
 26 |     mystr = re.search(
 27 |         r"eval[ ]*\([ ]*function[ ]*\([ ]*p[ ]*,[ ]*a[ ]*,[ ]*c["
 28 |         " ]*,[ ]*k[ ]*,[ ]*e[ ]*,[ ]*",
 29 |         source,
 30 |     )
 31 |     if mystr:
 32 |         begin_offset = mystr.start()
 33 |         beginstr = source[:begin_offset]
 34 |     if begin_offset != -1:
 35 |         """Find endstr"""
 36 |         source_end = source[begin_offset:]
 37 |         if source_end.split("')))", 1)[0] == source_end:
 38 |             try:
 39 |                 endstr = source_end.split("}))", 1)[1]
 40 |             except IndexPackerError:
 41 |                 endstr = ""
 42 |         else:
 43 |             endstr = source_end.split("')))", 1)[1]
 44 |     return mystr is not None
 45 | 
 46 | 
 47 | def unpack(source):
 48 |     """Unpacks P.A.C.K.E.R. packed js code."""
 49 |     payload, symtab, radix, count = _filterargs(source)
 50 | 
 51 |     if count != len(symtab):
 52 |         raise PackerError("Malformed p.a.c.k.e.r. symtab.")
 53 | 
 54 |     try:
 55 |         unbase = Unbaser(radix)
 56 |     except TypePackerError:
 57 |         raise PackerError("Unknown p.a.c.k.e.r. encoding.")
 58 | 
 59 |     def lookup(match):
 60 |         """Look up symbols in the synthetic symtab."""
 61 |         word = match.group(0)
 62 |         return symtab[unbase(word)] or word
 63 | 
 64 |     payload = payload.replace("\\\\", "\\").replace("\\'", "'")
 65 |     if sys.version_info.major == 2:
 66 |         source = re.sub(r"\b\w+\b", lookup, payload)
 67 |     else:
 68 |         source = re.sub(r"\b\w+\b", lookup, payload, flags=re.ASCII)
 69 |     return _replacestrings(source)
 70 | 
 71 | 
 72 | def _filterargs(source):
 73 |     """Juice from a source file the four args needed by decoder."""
 74 |     juicers = [
 75 |         (r"}\('(.*)', *(\d+|\[\]), *(\d+), *'(.*)'\.split\('\|'\), *(\d+), *(.*)\)\)"),
 76 |         (r"}\('(.*)', *(\d+|\[\]), *(\d+), *'(.*)'\.split\('\|'\)"),
 77 |     ]
 78 |     for juicer in juicers:
 79 |         args = re.search(juicer, source, re.DOTALL)
 80 |         if args:
 81 |             a = args.groups()
 82 |             if a[1] == "[]":
 83 |                 a = list(a)
 84 |                 a[1] = 62
 85 |                 a = tuple(a)
 86 |             try:
 87 |                 return a[0], a[3].split("|"), int(a[1]), int(a[2])
 88 |             except ValuePackerError:
 89 |                 raise PackerError("Corrupted p.a.c.k.e.r. data.")
 90 | 
 91 |     # could not find a satisfying regex
 92 |     raise PackerError(
 93 |         "Could not make sense of p.a.c.k.e.r data (unexpected code structure)"
 94 |     )
 95 | 
 96 | 
 97 | def _replacestrings(source):
 98 |     global beginstr
 99 |     global endstr
100 |     """Strip string lookup table (list) and replace values in source."""
101 |     match = re.search(r'var *(_\w+)\=\["(.*?)"\];', source, re.DOTALL)
102 | 
103 |     if match:
104 |         varname, strings = match.groups()
105 |         startpoint = len(match.group(0))
106 |         lookup = strings.split('","')
107 |         variable = "%s[%%d]" % varname
108 |         for index, value in enumerate(lookup):
109 |             source = source.replace(variable % index, '"%s"' % value)
110 |         return source[startpoint:]
111 |     return beginstr + source + endstr
112 | 
113 | 
114 | class Unbaser(object):
115 |     """Functor for a given base. Will efficiently convert
116 |     strings to natural numbers."""
117 | 
118 |     ALPHABET = {
119 |         62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
120 |         95: (
121 |             " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
122 |             "[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
123 |         ),
124 |     }
125 | 
126 |     def __init__(self, base):
127 |         self.base = base
128 | 
129 |         # fill elements 37...61, if necessary
130 |         if 36 < base < 62:
131 |             if not hasattr(self.ALPHABET, self.ALPHABET[62][:base]):
132 |                 self.ALPHABET[base] = self.ALPHABET[62][:base]
133 |         # attrs = self.ALPHABET
134 |         # print ', '.join("%s: %s" % item for item in attrs.items())
135 |         # If base can be handled by int() builtin, let it do it for us
136 |         if 2 <= base <= 36:
137 |             self.unbase = lambda string: int(string, base)
138 |         else:
139 |             # Build conversion dictionary cache
140 |             try:
141 |                 self.dictionary = dict(
142 |                     (cipher, index) for index, cipher in enumerate(self.ALPHABET[base])
143 |                 )
144 |             except KeyPackerError:
145 |                 raise TypePackerError("Unsupported base encoding.")
146 | 
147 |             self.unbase = self._dictunbaser
148 | 
149 |     def __call__(self, string):
150 |         return self.unbase(string)
151 | 
152 |     def _dictunbaser(self, string):
153 |         """Decodes a  value to an integer."""
154 |         ret = 0
155 |         for index, cipher in enumerate(string[::-1]):
156 |             ret += (self.base**index) * self.dictionary[cipher]
157 |         return ret
158 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <p align="center">
  2 |   <img src="/assets/logo.webp" alt="StreamFlix Providers" width="300"/>
  3 | </p>
  4 | 
  5 | 
  6 | 
  7 | **StreamFlix Providers**
  8 | 
  9 | StreamFlix Providers is a collection of scraper scripts that fetch streaming URLs from various online streaming platforms. These scripts allow you to extract video URLs from platforms like FileCDN and Vidsrc.to, facilitating the process of integrating streaming functionality into your applications or projects.
 10 | 
 11 | 
 12 | ## Features
 13 | 
 14 | - **Streaming URL Retrieval**: Fetch streaming URLs from popular online streaming platforms.
 15 | - **Subtitle Support**: Retrieve subtitles for movies and TV shows.
 16 | - **Download Options**: Provide direct download links for content.
 17 | - **Scalable and Efficient**: Designed to handle multiple requests with minimal latency.
 18 | 
 19 | ## Getting Started
 20 | 
 21 | ### Installation
 22 | 
 23 | To use StreamFlix API, follow these steps:
 24 | 
 25 | 1. Clone this repository to your local machine.
 26 | 2. Install the required dependencies by running `pip install -r requirements.txt`.
 27 | 3. Run the Flask server using `python3 main.py`.
 28 | 
 29 | ### Usage
 30 | 
 31 | #### Fetching Streaming URLs for Movies
 32 | 
 33 | To fetch streaming URLs for a movie, make a GET request to the `/api/sources/<tmdb_id>` endpoint, where `<tmdb_id>` is the TMDB ID of the movie.
 34 | 
 35 | Example:
 36 | 
 37 | ```http
 38 | GET /api/sources/12345
 39 | ```
 40 | 
 41 | #### Fetching Streaming URLs for TV Shows
 42 | 
 43 | To fetch streaming URLs for a TV show episode, make a GET request to the `/api/sources/<tmdb_id>/<season>/<episode>` endpoint, where `<tmdb_id>` is the TMDB ID of the TV show, `<season>` is the season number, and `<episode>` is the episode number.
 44 | 
 45 | Example:
 46 | 
 47 | ```http
 48 | GET /api/sources/67890/1/1
 49 | ```
 50 | 
 51 | ### API Responses
 52 | 
 53 | The API will respond with a JSON object containing the streaming URLs, subtitles (if available), and download options (if configured).
 54 | 
 55 | Example Response:
 56 | 
 57 | ```json
 58 | {
 59 |   "sources": [
 60 |     {
 61 |       "server": 1,
 62 |       "url": "https://example.com/stream1"
 63 |     },
 64 |     {
 65 |       "server": 2,
 66 |       "url": "https://example.com/stream2"
 67 |     }
 68 |   ],
 69 |   "captions": [
 70 |     {
 71 |       "language": "English",
 72 |       "url": "https://example.com/subtitles/en.srt"
 73 |     }
 74 |   ],
 75 |   "downloads": [
 76 |     {
 77 |       "quality": "1080p",
 78 |       "url": "https://example.com/downloads/movie.mp4"
 79 |     }
 80 |   ]
 81 | }
 82 | ```
 83 | 
 84 | 
 85 | ### How to Use the Scrapers
 86 | 
 87 | 1. **Download and Set Up**
 88 |    - Download the StreamFlix Providers `scrapers` folder from the repository.
 89 |    - Drag and drop the folder into your workspace or project directory.
 90 | 
 91 | 2. **Importing**
 92 |    - To use the scrapers in your code, import them as follows:
 93 |      ```python
 94 |      import scrapers.flixhq
 95 |      import scrapers.vidsrcto
 96 |      ```
 97 |    - Once imported, you can instantiate the scraper classes and use their methods to fetch streaming URLs.
 98 | 
 99 | 3. **Fetching Streaming URLs**
100 |    - Use the appropriate methods provided by each scraper to fetch streaming URLs based on the title or TMDB ID of the content.
101 |    - For example:
102 |      ```python
103 |      scraper = VidsrcTo()
104 |      response_data = scraper.fetch_source(108978, season=1, episode=1) 
105 |      print(f"Tv Show URL: {response_data}")
106 | 
107 |      ```
108 | ### Deploy on cloud providers
109 | [![Run on Replit](https://binbashbanana.github.io/deploy-buttons/buttons/remade/replit.svg)](https://replit.com/github/streamflix-one/providers)
110 | [![Remix on Glitch](https://binbashbanana.github.io/deploy-buttons/buttons/remade/glitch.svg)](https://glitch.com/edit/#!/import/github/streamflix-one/providers)
111 | [![Deploy on Railway](https://binbashbanana.github.io/deploy-buttons/buttons/remade/railway.svg)](https://railway.app/new/template?template=https://github.com/streamflix-one/providers)
112 | [![Deploy to Cyclic](https://binbashbanana.github.io/deploy-buttons/buttons/remade/cyclic.svg)](https://app.cyclic.sh/api/app/deploy/streamflix-one/providers)
113 | [![Deploy to Koyeb](https://binbashbanana.github.io/deploy-buttons/buttons/remade/koyeb.svg)](https://app.koyeb.com/deploy?type=git&repository=github.com/streamflix-one/providers&branch=main&name=Streamflix)
114 | [![Deploy to Render](https://binbashbanana.github.io/deploy-buttons/buttons/remade/render.svg)](https://render.com/deploy?repo=https://github.com/streamflix-one/providers)
115 | ### Contributing
116 | 
117 | Contributions to StreamFlix Providers are welcome! If you'd like to contribute, follow these steps:
118 | 
119 | 1. **Fork the Repository**
120 |    - Fork the StreamFlix Providers repository on GitHub.
121 | 
122 | 2. **Clone the Forked Repository**
123 |    - Clone your forked repository to your local machine.
124 | 
125 | 3. **Make Changes**
126 |    - Make the necessary changes or additions to the scraper scripts.
127 |    - Ensure that your code follows the existing coding style and conventions.
128 | 
129 | 4. **Commit and Push**
130 |    - Commit your changes and push them to your forked repository.
131 | 
132 | 5. **Create a Pull Request**
133 |    - Create a pull request from your forked repository to the main StreamFlix Providers repository.
134 |    - Provide a clear description of the changes you've made and the rationale behind them.
135 |    - Include any relevant details or documentation updates.
136 | 
137 | 6. **Review and Collaborate**
138 |    - Collaborate with other contributors and maintainers to review and refine your changes.
139 |    - Address any feedback or suggestions provided during the review process.
140 |    - Once your pull request is approved, it will be merged into the main repository.
141 | 
142 | ### Contributors
143 | 
144 | Acknowledgment and gratitude to all contributors who help improve StreamFlix Providers and make it more robust and versatile.
145 | 
146 | ---
147 | 
148 | Feel free to explore and utilize StreamFlix Providers in your projects. If you encounter any issues or have suggestions for improvement, don't hesitate to open an issue or submit a pull request. Happy streaming!
149 | 


--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
  1 | from flask import Flask, request, jsonify
  2 | from flask_cors import CORS
  3 | import concurrent.futures
  4 | import time
  5 | from scrapers.vidsrcto import VidsrcTo
  6 | from scrapers.vidsrcme import VidSrcMe
  7 | from scrapers.filecdn import FileCDNScraper
  8 | from scrapers.dreamfilmsw import DreamFilmSW
  9 | from scrapers.frembed import FrEmbed
 10 | from scrapers.twoembed import TwoEmbed
 11 | from scrapers.azm import AzmTo
 12 | from scrapers.meinecloud import MeineCloud
 13 | from scrapers.vixcloud import VixCloud
 14 | from scrapers.showflix import Showflix
 15 | from scrapers.streamium import Streamium
 16 | from scrapers.subtitles import get_subtitles
 17 | from scrapers.downloads import Downloads
 18 | import requests
 19 | 
 20 | 
 21 | app = Flask(__name__)
 22 | CORS(app)
 23 | 
 24 | def get_ip(request):
 25 |     x_forwarded_for = request.headers.get('X-Forwarded-For')
 26 |     if x_forwarded_for:
 27 |         ip = x_forwarded_for.split(',')[0].strip()
 28 |         return ip
 29 | 
 30 |     cf_connecting_ip = request.headers.get('CF-Connecting-IP')
 31 |     if cf_connecting_ip:
 32 |         return cf_connecting_ip
 33 | 
 34 |     return request.remote_addr
 35 | 
 36 | 
 37 | def get_movie_name(tmdb_movie_id):
 38 |     base_url = "https://api.themoviedb.org/3/movie/"
 39 |     api_key_param = f"?api_key=f1dd7f2494de60ef4946ea81fd5ebaba"
 40 | 
 41 |     start_time = time.time()  # Record the start time
 42 | 
 43 |     response = requests.get(f"{base_url}{tmdb_movie_id}{api_key_param}")
 44 | 
 45 |     end_time = time.time()  # Record the end time
 46 |     elapsed_time = end_time - start_time
 47 | 
 48 |     if response.status_code == 200:
 49 |         movie_data = response.json()
 50 |         print(f"Fetching movie name for TMDB ID {tmdb_movie_id} took {elapsed_time:.4f} seconds")
 51 |         return movie_data['title'], movie_data['release_date'].split("-")[0]
 52 |     else:
 53 |         print(f"Error: {response.status_code}. Fetching movie name for TMDB ID {tmdb_movie_id} took {elapsed_time:.4f} seconds")
 54 |         return f"Error: {response.status_code}"
 55 | 
 56 | def add_server_num(server_num, source):
 57 |     try:
 58 |         source['server'] = server_num
 59 |     except Exception as e:
 60 |         print(f"Error while adding server number {server_num} to source: {e}")
 61 |     return source
 62 | 
 63 | 
 64 | def scrape_sources(ip, tmdb_id, season=None, episode=None):
 65 |     start_time = time.time()  # Record the start time
 66 |     if season is None and episode is None:
 67 |         title, year = get_movie_name(tmdb_id)
 68 |     else:
 69 |         title, year = None, None    
 70 |     print(title)
 71 |     try:
 72 |         with concurrent.futures.ThreadPoolExecutor() as executor:
 73 |             futures = []
 74 | 
 75 |             vidsrcto_scraper = VidsrcTo()
 76 |             futures.append(executor.submit(vidsrcto_scraper.fetch_sources, tmdb_id, season, episode))
 77 |             vidsrcme_scraper = VidSrcMe()
 78 |             futures.append(executor.submit(vidsrcme_scraper.fetch_sources, tmdb_id, season, episode))
 79 | 
 80 |             if season is None and episode is None:
 81 | 
 82 |                 streamium_scraper = Streamium("f1dd7f2494de60ef4946ea81fd5ebaba")
 83 |                 futures.append(executor.submit(streamium_scraper.fetch_sources, tmdb_id))
 84 | 
 85 |                 meinecloud_scraper = MeineCloud(tmdb_api_key="f1dd7f2494de60ef4946ea81fd5ebaba")
 86 |                 futures.append(executor.submit(meinecloud_scraper.fetch_sources, ip, tmdb_id))
 87 | 
 88 |                 filecdn_movie_scraper = FileCDNScraper()
 89 |                 futures.append(executor.submit(filecdn_movie_scraper.scrape_movie, tmdb_id))
 90 | 
 91 |                 frembed_scraper = FrEmbed()
 92 |                 futures.append(executor.submit(frembed_scraper.fetch_sources, tmdb_id, season, episode))
 93 | 
 94 |                 vixcloud_scraper = VixCloud()
 95 |                 futures.append(executor.submit(vixcloud_scraper.fetch_sources, title))
 96 | 
 97 |                 twoembed_scraper = TwoEmbed()
 98 |                 futures.append(executor.submit(twoembed_scraper.fetch_sources, tmdb_id, ip, season, episode))
 99 | 
100 |                 showflix_scraper = Showflix()
101 |                 futures.append(executor.submit(showflix_scraper.fetch_sources, title, ip))
102 | 
103 |                 azmto_scraper = AzmTo()
104 |                 futures.append(executor.submit(azmto_scraper.fetch_sources, ip, title))
105 |                 
106 |             else:
107 |                 filecdn_tv_show_scraper = FileCDNScraper()
108 |                 futures.append(executor.submit(filecdn_tv_show_scraper.scrape_tv_show, tmdb_id, season, episode))
109 | 
110 |             dreamfilmsw_scraper = DreamFilmSW()
111 |             futures.append(executor.submit(dreamfilmsw_scraper.fetch_sources, tmdb_id, season, episode))
112 | 
113 |             concurrent.futures.wait(futures)
114 | 
115 |             sources = []
116 |             server = 1
117 |             for future in futures:
118 |                 try:
119 |                     result = future.result()
120 |                     if result:
121 |                         # print(result)
122 |                         sources.append(add_server_num(server, result))
123 |                     server += 1    
124 |                 except Exception as e:
125 |                     print(f"Error in scraper: {e}")
126 |                     server += 1
127 | 
128 |             end_time = time.time() 
129 |             elapsed_time = end_time - start_time
130 |             print(f"Scraping for {len(sources)} sources took {elapsed_time:.2f} seconds")  # Print the elapsed time
131 | 
132 |             return sources
133 | 
134 |     except Exception as e:
135 |         print(f"Error scraping sources: {e}")
136 |         return None
137 | 
138 | 
139 | @app.route('/api/sources/<tmdb_id>', methods=['GET'])
140 | def scrape_movie_endpoint(tmdb_id):
141 |     movie_name, year = get_movie_name(tmdb_id)
142 |     start_time = time.time()
143 |     ip = get_ip(request)
144 | 
145 |     if not tmdb_id:
146 |         return "Error: TMDB ID is required.", 400
147 |     dl_scraper = Downloads()
148 |     sources = scrape_sources(ip, tmdb_id)
149 |     downloads = dl_scraper.scrape_movies(movie_name, year)
150 |     subtitles = get_subtitles(tmdb_id)
151 |     formatted_json = {
152 |         'sources': sources,
153 |         'captions': subtitles,
154 |         'downloads': downloads
155 |     }
156 |     end_time = time.time()  # record the end time
157 |     elapsed_time = end_time - start_time
158 |     print(f"Scraping for {len(sources)} sources and {len(subtitles)} subtitles took {elapsed_time:.2f} seconds")  # Print the elapsed time
159 |     if sources:
160 |         return jsonify(formatted_json)
161 |     else:
162 |         return "Error scraping sources.", 500
163 | 
164 | @app.route('/api/sources/<tmdb_id>/<season>/<episode>', methods=['GET'])
165 | def scrape_tv_show_endpoint(tmdb_id, season, episode):
166 |     start_time = time.time()
167 |     ip = get_ip(request)
168 | 
169 |     if not tmdb_id:
170 |         return "Error: TMDB ID is required.", 400
171 | 
172 |     sources = scrape_sources(ip, tmdb_id, season, episode)
173 |     subtitles = get_subtitles(tmdb_id, season, episode)
174 |     formatted_json = {
175 |         'sources': sources,
176 |         'captions': subtitles
177 |     }
178 |     end_time = time.time()  # record the end time
179 |     elapsed_time = end_time - start_time
180 |     print(f"Scraping for {len(sources)} sources and {len(subtitles)} subtitles took {elapsed_time:.2f} seconds")  # Print the elapsed time
181 |     if sources:
182 |         return jsonify(formatted_json)
183 |     else:
184 |         return "Error scraping sources.", 500
185 | 
186 | if __name__ == '__main__':
187 |     app.run(host="0.0.0.0", port=8000)
188 | 


--------------------------------------------------------------------------------
/scrapers/vidsrcto.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | from bs4 import BeautifulSoup
  3 | import base64
  4 | from urllib.parse import unquote
  5 | from typing import Union
  6 | import re
  7 | import time
  8 | from urllib.parse import quote
  9 | 
 10 | class VidsrcTo:
 11 |     def __init__(self):
 12 |         self.base_url = "https://vidsrc.to/embed/"
 13 |         self.headers = {
 14 |             "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 15 |             "accept-language": "en-GB,en;q=0.9",
 16 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
 17 |             "sec-ch-ua-mobile": "?1",
 18 |             "sec-ch-ua-platform": "\"Android\"",
 19 |             "sec-fetch-dest": "document",
 20 |             "sec-fetch-mode": "navigate",
 21 |             "sec-fetch-site": "none",
 22 |             "sec-fetch-user": "?1",
 23 |             "sec-gpc": "1",
 24 |             "upgrade-insecure-requests": "1"
 25 |         }
 26 | 
 27 | 
 28 |     def get_embed_sources(self, id):
 29 |       url = f"https://vidsrc.to/ajax/embed/episode/{id}/sources"
 30 | 
 31 | 
 32 |       response = requests.get(url, headers=self.headers)
 33 | 
 34 |       if response.status_code == 200:
 35 |           # print("Request successful")
 36 |           # print(response.text)
 37 |           return response.json()["result"][0]["id"]
 38 |       else:
 39 |           # print(f"Request failed with status code {response.status_code}")
 40 |           return None
 41 | 
 42 | 
 43 |     def get_vidsrc_keys(self):
 44 |       # print("Getting keys...")
 45 |       url = "https://github.com/Ciarands/vidsrc-keys/blob/main/keys.json"
 46 |       response = requests.get(url)
 47 |       if response.status_code != 200:
 48 |           # print(f"Failed to fetch content from {url}. Status code: {response.status_code}")
 49 |           return None
 50 | 
 51 |       pattern = re.compile(r'"blob":{"rawLines":\["(.*?)"\]')
 52 |       match = pattern.search(response.text)
 53 | 
 54 |       if match:
 55 |           result_str = match.group(1)
 56 | 
 57 |           extracted_values = result_str.replace('\\', '').replace('"', '').strip("[").split(',')
 58 |           return extracted_values[0], extracted_values[1]
 59 | 
 60 |       else:
 61 |           # print("Pattern not found in the content.")
 62 |           return None
 63 | 
 64 |     def get_id(self, tmdb_id, season=None, episode=None):
 65 |         # print(f"Getting id for tmdb_id: {tmdb_id}")
 66 |         base_url = self.base_url
 67 | 
 68 |         if season and episode:
 69 |             url = f"{base_url}tv/{tmdb_id}/{season}/{episode}"
 70 |         else:
 71 |             url = f"{base_url}movie/{tmdb_id}"
 72 |         # print(url)
 73 |         response = requests.get(url, headers=self.headers)
 74 | 
 75 |         if response.status_code == 200:
 76 |             soup = BeautifulSoup(response.text, 'html.parser')
 77 | 
 78 |             a_element = soup.select_one('.episodes li a')
 79 | 
 80 |             if a_element:
 81 |                 data_id = a_element.get('data-id')
 82 |                 r = self.get_embed_sources(data_id)
 83 |                 return r
 84 |             else:
 85 |                 raise ValueError("Could not find the data-id attribute")
 86 | 
 87 |         else:
 88 |             raise ValueError(f"Request failed with status code {response.status_code}")
 89 | 
 90 |     def get_encrypted_sources(self, data_id):
 91 |         url = f"https://vidsrc.to/ajax/embed/source/{data_id}"
 92 |         # print(url)
 93 |         response = requests.get(url, headers=self.headers)
 94 |         if response.status_code == 200:
 95 |             # print(response.text)
 96 |             return response.json()["result"]["url"]  # Assuming the response is JSON
 97 |         else:
 98 |             raise ValueError(f"Failed to fetch data: {response.status_code}")
 99 | 
100 |     def decode_data(self, key: str, data: Union[bytearray, str]) -> bytearray:
101 |         key_bytes = bytes(key, 'utf-8')
102 |         s = bytearray(range(256))
103 |         j = 0
104 | 
105 |         for i in range(256):
106 |             j = (j + s[i] + key_bytes[i % len(key_bytes)]) & 0xff
107 |             s[i], s[j] = s[j], s[i]
108 | 
109 |         decoded = bytearray(len(data))
110 |         i = 0
111 |         k = 0
112 | 
113 |         for index in range(len(data)):
114 |             i = (i + 1) & 0xff
115 |             k = (k + s[i]) & 0xff
116 |             s[i], s[k] = s[k], s[i]
117 |             t = (s[i] + s[k]) & 0xff
118 | 
119 |             if isinstance(data[index], str):
120 |                 decoded[index] = ord(data[index]) ^ s[t]
121 |             elif isinstance(data[index], int):
122 |                 decoded[index] = data[index] ^ s[t]
123 |             else:
124 |                 raise TypeError("Invalid data type")
125 | 
126 |         return decoded
127 | 
128 |     def handle_vidplay(self, url, provider_base) -> str:
129 |         furl = url
130 |         url = url.split("?")
131 | 
132 |         key1, key2 = self.get_vidsrc_keys()
133 | 
134 |         decoded_id = self.decode_data(key1, url[0].split('/e/')[-1])
135 |         encoded_result = self.decode_data(key2, decoded_id)
136 |         encoded_base64 = base64.b64encode(encoded_result)
137 |         key = encoded_base64.decode('utf-8').replace('/', '_')
138 |         # print(furl)
139 |         req = requests.get(f"{provider_base}/futoken", headers={"Referer": furl})
140 |         fu_key = re.search(r"var\s+k\s*=\s*'([^']+)'", req.text).group(1)
141 | 
142 |         data = f"{fu_key},{','.join([str(ord(fu_key[i % len(fu_key)]) + ord(key[i])) for i in range(len(key))])}"
143 | 
144 |         req = requests.get(
145 |             f"{provider_base}/mediainfo/{data}?{url[1]}&autostart=true",
146 |             headers={"Referer": furl}
147 |         )
148 |         req_data = req.json()
149 | 
150 |         if type(req_data.get("result")) == dict:
151 |             src = req_data.get("result").get("sources", [{}])[0].get("file").replace("#.mp4", "")
152 |             thumbnails = req_data.get("result").get("tracks", [{}])[0].get("file").replace("#.mp4", "")
153 |             return  {'url': src, 'source': 'VidsrcTo', 'proxy': 'True', 'lang': 'en', 'type': 'hls', 'thumbnails': thumbnails}
154 |         return 1401
155 | 
156 | 
157 |     def get_tmdb_id(self, tmdb_id):
158 |         return tmdb_id
159 | 
160 |     def fetch_sources(self, tmdb_id, season=None, episode=None):
161 |         try:
162 |             data_id = self.get_id(tmdb_id, season, episode)
163 |             encrypted_source_url = self.get_encrypted_sources(data_id)
164 | 
165 |             standardized_input = encrypted_source_url.replace('_', '/').replace('-', '+')
166 |             binary_data = base64.b64decode(standardized_input)
167 | 
168 |             encoded = bytearray(binary_data)
169 | 
170 |             # SPECIAL [KEY]
171 |             key_bytes = bytes('WXrUARXb1aDLaZjI', 'utf-8')
172 |             j = 0
173 |             s = bytearray(range(256))
174 | 
175 |             for i in range(256):
176 |                 j = (j + s[i] + key_bytes[i % len(key_bytes)]) & 0xff
177 |                 s[i], s[j] = s[j], s[i]
178 | 
179 |             decoded = bytearray(len(encoded))
180 |             i = 0
181 |             k = 0
182 | 
183 |             for index in range(len(encoded)):
184 |                 i = (i + 1) & 0xff
185 |                 k = (k + s[i]) & 0xff
186 |                 s[i], s[k] = s[k], s[i]
187 |                 t = (s[i] + s[k]) & 0xff
188 |                 decoded[index] = encoded[index] ^ s[t]
189 | 
190 |             decoded_text = decoded.decode('utf-8')
191 |             unquoted_text = unquote(decoded_text)
192 |             # print(unquoted_text)
193 |             provider_base = unquoted_text.split('/e/')[0]
194 |             return self.handle_vidplay(unquoted_text, provider_base)
195 | 
196 |         except Exception as e:
197 |             return f"Error fetching sources: {e}"
198 | 
199 | 


--------------------------------------------------------------------------------
/scrapers/dreamfilmsw.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | from bs4 import BeautifulSoup
  3 | import re
  4 | import cloudscraper
  5 | 
  6 | class DreamFilmSW:
  7 |     def __init__(self):
  8 |         self.php_session_id = self.get_php_session_id("https://dreamfilmsw.net/")
  9 | 
 10 |     def get_iframe_source(self, iframe_src):
 11 |         scraper = cloudscraper.create_scraper()
 12 |         headers = {
 13 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 14 |             "Accept-Language": "en-GB,en;q=0.8",
 15 |             "Connection": "keep-alive",
 16 |             "Host": "vidmoly.net",
 17 |             "Referer": "https://dreamfilmsw.net/",
 18 |             "sec-ch-ua": '"Brave";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
 19 |             "sec-ch-ua-mobile": "?0",
 20 |             "sec-ch-ua-platform": '"Windows"',
 21 |             "Sec-Fetch-Dest": "iframe",
 22 |             "Sec-Fetch-Mode": "navigate",
 23 |             "Sec-Fetch-Site": "cross-site",
 24 |             "Sec-Fetch-User": "?1",
 25 |             "Sec-GPC": "1",
 26 |             "Upgrade-Insecure-Requests": "1",
 27 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
 28 |         }
 29 | 
 30 | 
 31 |         response = requests.get(iframe_src.replace('.to', '.net'), headers=headers)
 32 |         if response.status_code == 200:
 33 |             return response.text
 34 |         else:
 35 |             print(f"Request to iframe data-src failed with status code: {response.status_code}")
 36 |             return None
 37 | 
 38 |     def extract_m3u8_link(self, source):
 39 |         regex_pattern = r'sources: \[{file:"(.*?)"\}\]'
 40 |         match = re.search(regex_pattern, source)
 41 | 
 42 |         if match:
 43 |             return match.group(1)
 44 |         else:
 45 |             print("No m3u8 link found in the source.")
 46 |             return None
 47 | 
 48 |     def fetch_movie_details(self, slug):
 49 |         url = f'https://dreamfilmsw.net/{slug}'
 50 |         print(url)
 51 |         headers = {
 52 |             "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 53 |             "accept-language": "en-GB,en;q=0.6",
 54 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
 55 |             "sec-ch-ua-mobile": "?1",
 56 |             "sec-ch-ua-platform": "\"Android\"",
 57 |             "sec-fetch-dest": "document",
 58 |             "sec-fetch-mode": "navigate",
 59 |             "sec-fetch-site": "same-origin",
 60 |             "sec-fetch-user": "?1",
 61 |             "sec-gpc": "1",
 62 |             "upgrade-insecure-requests": "1",
 63 |             "cookie": f"PHPSESSID={self.php_session_id}",
 64 |             "Referer": "https://dreamfilmsw.net/",
 65 |             "Referrer-Policy": "strict-origin-when-cross-origin"
 66 |         }
 67 | 
 68 |         response = requests.get(url, headers=headers)
 69 | 
 70 |         if response.status_code == 200:
 71 |             soup = BeautifulSoup(response.content, 'html.parser')
 72 |             iframe = soup.find('iframe', class_='moly-en') or soup.find('iframe', class_='Moly')
 73 | 
 74 |             if iframe:
 75 |                 data_src = iframe.get('data-src')
 76 |                 print(data_src)
 77 |                 if data_src:
 78 |                     return data_src
 79 |                 else:
 80 |                     print("No 'data-src' attribute found in the iframe.")
 81 |             else:
 82 |                 print("No iframe with class 'moly-en' found.")
 83 |         else:
 84 |             print(f"Request failed with status code: {response.status_code}")
 85 | 
 86 |         return None
 87 | 
 88 |     def get_php_session_id(self, url):
 89 |         headers = {
 90 |             "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 91 |             "accept-language": "en-GB,en;q=0.6",
 92 |             "cache-control": "max-age=0",
 93 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
 94 |             "sec-ch-ua-mobile": "?1",
 95 |             "sec-ch-ua-platform": "\"Android\"",
 96 |             "sec-fetch-dest": "document",
 97 |             "sec-fetch-mode": "navigate",
 98 |             "sec-fetch-site": "none",
 99 |             "sec-fetch-user": "?1",
100 |             "sec-gpc": "1",
101 |             "upgrade-insecure-requests": "1"
102 |         }
103 | 
104 |         response = requests.get(url, headers=headers)
105 | 
106 |         if response.status_code == 200:
107 |             if 'Set-Cookie' in response.headers:
108 |                 cookies = requests.utils.dict_from_cookiejar(response.cookies)
109 |                 php_session_id = cookies.get('PHPSESSID')
110 |                 return php_session_id
111 |             else:
112 |                 print("Set-Cookie header not found in the response.")
113 |         else:
114 |             print(f"Request failed with status code: {response.status_code}")
115 | 
116 |     def search_with_php_session_id(self, query):
117 |         search_url = "https://dreamfilmsw.net/search"
118 | 
119 |         headers = {
120 |             "accept": "application/json, text/javascript, */*; q=0.01",
121 |             "accept-language": "en-GB,en;q=0.6",
122 |             "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
123 |             "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
124 |             "sec-ch-ua-mobile": "?1",
125 |             "sec-ch-ua-platform": "\"Android\"",
126 |             "sec-fetch-dest": "empty",
127 |             "sec-fetch-mode": "cors",
128 |             "sec-fetch-site": "same-origin",
129 |             "sec-gpc": "1",
130 |             "x-requested-with": "XMLHttpRequest",
131 |             "cookie": f"PHPSESSID={self.php_session_id}",
132 |             "Referer": "https://dreamfilmsw.net/",
133 |             "Referrer-Policy": "strict-origin-when-cross-origin"
134 |         }
135 | 
136 |         data = {"query": query}
137 | 
138 |         response = requests.post(search_url, headers=headers, data=data)
139 | 
140 |         if response.status_code == 200:
141 |             return response.json()
142 |         else:
143 |             print(f"Request failed with status code: {response.status_code}")
144 |             return None
145 | 
146 | 
147 |     def convert_tmdb_to_imdb(self, tmdb_id, is_tv_show=False):
148 |       base_url = "https://api.themoviedb.org/3"
149 |       endpoint = "tv" if is_tv_show else "movie"
150 |       tmdb_api_key = "f1dd7f2494de60ef4946ea81fd5ebaba"
151 |   
152 |       tmdb_url = f"{base_url}/{endpoint}/{tmdb_id}/external_ids?api_key={tmdb_api_key}"
153 |   
154 |       response = requests.get(tmdb_url)
155 |   
156 |       if response.status_code == 200:
157 |           tmdb_data = response.json()
158 |           imdb_id = tmdb_data.get("imdb_id")
159 |           return imdb_id
160 |       else:
161 |           print(f"Failed to convert TMDB ID to IMDb ID. Status code: {response.status_code}")
162 |           return None
163 |       
164 |     def fetch_sources(self, tmdb_id, season=None, episode=None):
165 |         imdb_id = self.convert_tmdb_to_imdb(tmdb_id, is_tv_show=(season is not None and episode is not None))
166 |         search_result = self.search_with_php_session_id(imdb_id)
167 | 
168 |         if search_result:
169 |             slug = search_result['result'][0]['slug']
170 | 
171 |             if season is not None and episode is not None:
172 |                 slug = f"series/{slug}/season-{season}/episode-{episode}"
173 | 
174 |             iframe_src = self.fetch_movie_details(slug)
175 | 
176 |             if iframe_src:
177 |                 iframe_content = self.get_iframe_source(iframe_src)
178 | 
179 |                 if iframe_content:
180 |                     m3u8_link = self.extract_m3u8_link(iframe_content)
181 |                     return {'url': f'https://m3u8.justchill.workers.dev/?url={m3u8_link}&referer=vidmoly.me', 'source': 'DreamFilmSW', 'proxy': 'True', 'lang': 'en', 'type': 'hls'}
182 | 
183 | # Example usage
184 | # scraper = DreamFilmSW()
185 | # response_data = scraper.fetch_source(438631)
186 | # print(f"Tv URL: {response_data}")
187 | 


--------------------------------------------------------------------------------
/scrapers/azm.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | import re
  3 | import random
  4 | import string
  5 | import time
  6 | 
  7 | class AzmTo:
  8 |     def __init__(self):
  9 |         self.sitekey = "0x4AAAAAAALn0BYsCrtFUbm_" # dood site key
 10 |         self.invisible = True
 11 |         self.base_url = "https://azm.to/live" # website with dood urls, low protection asw
 12 |         self.headers = {
 13 |             "accept": "*/*",
 14 |             "accept-language": "en-GB,en;q=0.9",
 15 |             "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
 16 |             "sec-ch-ua": "\"Not A(Brand\";v=\"99\", \"Brave\";v=\"121\", \"Chromium\";v=\"121\"",
 17 |             "sec-ch-ua-mobile": "?0",
 18 |             "sec-ch-ua-platform": "\"Windows\"",
 19 |             "sec-fetch-dest": "empty",
 20 |             "sec-fetch-mode": "cors",
 21 |             "sec-fetch-site": "same-origin",
 22 |             "sec-gpc": "1",
 23 |             "x-requested-with": "XMLHttpRequest",
 24 |             "Referer": "https://azm.to/",
 25 |             "Referrer-Policy": "strict-origin",
 26 |         }
 27 | 
 28 |     def generate_random_string(self, length):
 29 |         characters = string.ascii_letters + string.digits
 30 |         return ''.join(random.choice(characters) for _ in range(length))
 31 | 
 32 |     def solve_and_validate_captcha(self, url):
 33 |       sitekey = "0x4AAAAAAALn0BYsCrtFUbm_" # Doodstream site key
 34 |       invisible = True
 35 |   
 36 |       def solve_captcha(sitekey, invisible, url):
 37 |           endpoint = "https://turn.seized.live/solve"
 38 |   
 39 |           headers = {
 40 |               "Content-Type": "application/json",
 41 |           }
 42 |   
 43 |           data = {
 44 |               "sitekey": sitekey,
 45 |               "invisible": invisible,
 46 |               "url": url,
 47 |           }
 48 |   
 49 |           try:
 50 |               response = requests.post(endpoint, json=data, headers=headers)
 51 |   
 52 |               if response.status_code == 200:
 53 |                   return response.json()
 54 |               else:
 55 |                   print(f"Error: {response.status_code}, {response.text}")
 56 |                   return None
 57 |           except Exception as e:
 58 |               print(f"Error: {e}")
 59 |               return None
 60 |   
 61 |       captcha_result = solve_captcha(sitekey, invisible, url)
 62 |   
 63 |       if captcha_result:
 64 |           print(f"Captcha solved successfully! Token: {captcha_result['token']}")
 65 |       else:
 66 |           print("Failed to solve captcha.")
 67 |           return None
 68 |   
 69 |       token = captcha_result["token"]
 70 |   
 71 |       headers = {
 72 |           "Host": "d0000d.com",
 73 |           "Connection": "keep-alive",
 74 |           "sec-ch-ua": "\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"",
 75 |           "DNT": "1",
 76 |           "sec-ch-ua-mobile": "?0",
 77 |           "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
 78 |           "sec-ch-ua-platform": "\"macOS\"",
 79 |           "Accept": "*/*",
 80 |           "Sec-Fetch-Site": "cross-site",
 81 |           "Sec-Fetch-Mode": "no-cors",
 82 |           "Sec-Fetch-Dest": "video",
 83 |           "Referer": "https://d0000d.com/",
 84 |           "Accept-Language": "en-US,en;q=0.9,ar;q=0.8",
 85 |           "Pragma": "no-cache",
 86 |           "Cache-Control": "no-cache"
 87 |       }
 88 |   
 89 |       print(url)
 90 |       response = requests.get(f"https://d0000d.com/dood?op=validate&gc_response={token}", headers=headers)
 91 |       html_response = response.text
 92 |   
 93 |       # You can return or process the html_response as needed
 94 |       return html_response
 95 | 
 96 |     def fetch_sources(self, user_ip, movie_name):
 97 |         data = {"q": movie_name}
 98 |         response = requests.post(self.base_url, headers=self.headers, data=data)
 99 | 
100 |         html_response = response.text
101 |         pattern = r'<a href="(/movie/[^"]+)" class="result[^>]+>\s*<h2 class="result__title">\s*([^<]+)\s*</h2>'
102 |         matches = re.findall(pattern, html_response)
103 | 
104 |         movies_list = [{"name": name.strip(), "link": link} for link, name in matches]
105 | 
106 |         url = f"https://azm.to{movies_list[0]['link']}"
107 |         response = requests.get(url, headers=self.headers)
108 |         html_response = response.text
109 | 
110 |         match = re.search(r'https://d0o0d\.com/e/[^\'"]+', html_response)
111 | 
112 |         if match:
113 |             d00d_url = match.group()
114 |             print(f"d00d URL: {d00d_url}")
115 |         else:
116 |             print("d00d URL not found in the HTML response.")
117 |             
118 |             return None
119 | 
120 |         url = d00d_url.replace("d0o0d.com", "d0000d.com")
121 |         base_url = url
122 |         headers = {
123 |             "Host": "d0000d.com",
124 |             "Connection": "keep-alive",
125 |             "sec-ch-ua": "\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"",
126 |             "DNT": "1",
127 |             "sec-ch-ua-mobile": "?0",
128 |             "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
129 |             "sec-ch-ua-platform": "\"macOS\"",
130 |             "Accept": "*/*",
131 |             "Sec-Fetch-Site": "cross-site",
132 |             "Sec-Fetch-Mode": "no-cors",
133 |             "Sec-Fetch-Dest": "video",
134 |             "Referer": url,
135 |             "Accept-Language": "en-US,en;q=0.9,ar;q=0.8",
136 |             "Pragma": "no-cache",
137 |             "Cache-Control": "no-cache",
138 |             "X-Requested-With": "XMLHttpRequest",
139 |             "X-Forwarded-For": user_ip
140 |   
141 |         }
142 | 
143 |         response = requests.get(url, headers=headers)
144 |         html_response = response.text
145 | 
146 |         match = re.search(r"\$\.get\('\/pass_md5([^']+)", html_response)
147 | 
148 |         if match:
149 |             d00d_url = match.group().replace("$.get('", "")
150 |             print(f"md5 URL: {d00d_url}")
151 |         else:
152 |             print("md5 URL not found in the HTML response, trying to solve captcha...")
153 |             self.solve_and_validate_captcha(url)
154 |             response = requests.get(url, headers=headers)
155 |             html_response = response.text
156 |             match = re.search(r"\$\.get\('\/pass_md5([^']+)", html_response)
157 |             if match:
158 |               d00d_url = match.group().replace("$.get('", "")
159 |               print(f"md5 URL: {d00d_url}")
160 |             else:
161 |               return None
162 | 
163 |         data_for_later = re.search(r'\?token=([^&]+)&expiry=', html_response)
164 |         if data_for_later:
165 |             data_for_later = data_for_later.group(1)
166 |             print(f"data_for_later: {data_for_later}")
167 | 
168 |         md5_url = f"https://d0000d.com{d00d_url}"
169 |       
170 |         headers = {
171 |             'Accept': '*/*',
172 |             'Accept-Language': 'en-GB,en;q=0.6',
173 |             'Cache-Control': 'no-cache',
174 |             'Connection': 'keep-alive',
175 |             'Cookie': 'lang=1',
176 |             'Host': 'd0000d.com',
177 |             'Pragma': 'no-cache',
178 |             'Referer': base_url,
179 |             'sec-ch-ua': '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
180 |             'sec-ch-ua-mobile': '?0',
181 |             'sec-ch-ua-platform': '"Windows"',
182 |             'Sec-Fetch-Dest': 'empty',
183 |             'Sec-Fetch-Mode': 'cors',
184 |             'Sec-Fetch-Site': 'same-origin',
185 |             'Sec-GPC': '1',
186 |             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
187 |             'X-Requested-With': 'XMLHttpRequest',
188 |             "X-Forwarded-For": user_ip,
189 |         }
190 | 
191 |         response = requests.get(md5_url, headers=headers)
192 |         expiry_timestamp = int(time.time() * 1000)
193 |         constructed_url = f"{response.text}{self.generate_random_string(10)}?token={data_for_later}&expiry={expiry_timestamp}"
194 |         return  {'url': constructed_url, 'source': 'AzmTo', 'proxy': 'False', 'lang': 'en', 'type': 'mp4'}
195 | 
196 | # Example usage:
197 | # scraper = AzmTo()
198 | # user_ip = "86.16.28.244"
199 | # movie_name = "the beekeeper"
200 | # response_data = scraper.fetch_source(user_ip, movie_name)
201 | # print(f"Movie URL: {response_data}")
202 | 


--------------------------------------------------------------------------------
/scrapers/vidsrcme.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | import re
  3 | import base64
  4 | from bs4 import BeautifulSoup
  5 | 
  6 | # Love to Ciarands for a tonne of the logic
  7 | 
  8 | class VidSrcMe:
  9 |     def __init__(self):
 10 |         pass
 11 | 
 12 |     def decode_src(self, encoded, seed):
 13 |         encoded_buffer = bytes.fromhex(encoded)
 14 |         decoded = ""
 15 |         for i in range(len(encoded_buffer)):
 16 |             decoded += chr(encoded_buffer[i] ^ ord(seed[i % len(seed)]))
 17 |         return decoded
 18 | 
 19 |     def decode_base64_url_safe(self, s):
 20 |         standardized_input = s.replace('_', '/').replace('-', '+')
 21 |         binary_data = base64.b64decode(standardized_input)
 22 |         return bytearray(binary_data)
 23 | 
 24 |     def decode_hls_url(self, encoded_url):
 25 |         def format_hls_b64(data):
 26 |             encoded_b64 = re.sub(r"\/@#@\/[^=\/]+==", "", data)
 27 |             if re.search(r"\/@#@\/[^=\/]+==", encoded_b64):
 28 |                 return format_hls_b64(encoded_b64)
 29 |             return encoded_b64
 30 | 
 31 |         formatted_b64 = format_hls_b64(encoded_url[2:])
 32 |         b64_data = self.decode_base64_url_safe(formatted_b64)
 33 |         return b64_data.decode("utf-8")
 34 | 
 35 |     def resolve_source(self, url, referrer):
 36 |         req = requests.get(url, headers={"Referer": referrer})
 37 |         if req.status_code != 200:
 38 |             print(f"[Vidsrc] Failed to retrieve media, status code: {req.status_code}...")
 39 |             return None
 40 | 
 41 |         encoded_hls_url = re.search(r'file:"([^"]*)"', req.text)
 42 |         hls_password_url = re.search(r'var pass_path = "(.*?)";', req.text)
 43 | 
 44 |         if not encoded_hls_url or not hls_password_url:
 45 |             print("[Vidsrc] Failed to extract hls or password url...")
 46 |             return None
 47 | 
 48 |         hls_password_url = hls_password_url.group(1)
 49 |         if hls_password_url.startswith("//"):
 50 |             hls_password_url = f"https:{hls_password_url}"
 51 | 
 52 |         hls_url = self.decode_hls_url(encoded_hls_url.group(1))
 53 |         requests.get(hls_password_url, headers={"Referer": referrer})
 54 | 
 55 |         return hls_url
 56 |         
 57 |     def fetch_sources(self, tmdb_id, season=None, episode=None):
 58 |         if season is None and episode is None:
 59 |           url = f"https://vidsrc.xyz/embed/movie/{tmdb_id}"
 60 |         else:
 61 |           url = f"https://vidsrc.xyz/embed/tv/{tmdb_id}/{season}-{episode}"
 62 |         headers = {
 63 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 64 |             "Accept-Language": "en-GB,en;q=0.6",
 65 |             "Connection": "keep-alive",
 66 |             "Host": "vidsrc.xyz",
 67 |             "sec-ch-ua": '"Brave";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
 68 |             "sec-ch-ua-mobile": "?0",
 69 |             "sec-ch-ua-platform": '"Windows"',
 70 |             "Sec-Fetch-Dest": "document",
 71 |             "Sec-Fetch-Mode": "navigate",
 72 |             "Sec-Fetch-Site": "none",
 73 |             "Sec-Fetch-User": "?1",
 74 |             "Sec-GPC": "1",
 75 |             "Upgrade-Insecure-Requests": "1",
 76 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
 77 |         }
 78 | 
 79 |         response = requests.get(url, headers=headers)
 80 |         if response.status_code != 200:
 81 |             print(f"[Vidsrc] Failed to fetch sources, status code: {response.status_code}")
 82 |             return None
 83 | 
 84 |         html_content = response.text
 85 |         soup = BeautifulSoup(html_content, 'html.parser')
 86 |         iframe_tag = soup.find('iframe', id='player_iframe')
 87 |         iframe_src = f"https:{iframe_tag['src']}"
 88 |         print(iframe_src)
 89 |         src = self.fetch(iframe_src)
 90 |         soup = BeautifulSoup(src, 'html.parser')
 91 |         cf_turnstile_div = soup.find('div', class_='cf-turnstile', attrs={'data-sitekey': '0x4AAAAAAATD6DukOTUdZEnE', 'data-callback': 'cftCallback'})
 92 | 
 93 |         if cf_turnstile_div:
 94 |             print("Found cf-turnstile div. Executing turnstile solver...")
 95 |             body = {
 96 |               "sitekey": "0x4AAAAAAATD6DukOTUdZEnE",
 97 |               "url": iframe_src,
 98 |               "invisible": True
 99 |             }
100 |             r = requests.post("https://turn.seized.live/solve", json=body)
101 |             token = r.json()["token"]
102 |             print("Solved :: " + token)
103 |             rcp_verify_result = self.rcp_verify(iframe_src, token)
104 |             if not rcp_verify_result:
105 |                 print("Failed to verify captcha.")
106 |                 return None
107 | 
108 |             src = self.fetch(iframe_src)
109 | 
110 |         # soup = BeautifulSoup(src, "html.parser")
111 |         # encoded = soup.find("div", {"id": "hidden"}).get("data-h")
112 |         # seed = soup.find("body").get("data-i")
113 | 
114 |         # source = self.decode_src(encoded, seed)
115 |         match = re.search(r"src:\s*'([^']+)'", src)
116 |   
117 |         if match:
118 |             source = match.group(1)
119 |             print("Source URL:", source)
120 |         else:
121 |             print("Source URL not found.")
122 |             source = ""
123 |         if source.startswith("//"):
124 |             source = f"https:{source}"
125 | 
126 |         req = requests.get(source, allow_redirects=False, headers={"Referer": "https://vidsrc.stream/"})
127 | 
128 |         prorcp = req.headers.get("location")
129 | 
130 |         final = self.resolve_source(url=prorcp, referrer=iframe_src)
131 | 
132 |         return {'url': final, 'source': 'VidSrcMe', 'proxy': 'False', 'lang': 'en', 'type': 'hls'}
133 | 
134 |     def fetch(self, url):
135 |         headers = {
136 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
137 |             "Accept-Language": "en-GB,en;q=0.6",
138 |             "Connection": "keep-alive",
139 |             "Host": "vidsrc.stream",
140 |             "Referer": "https://vidsrc.xyz/",
141 |             "sec-ch-ua": '"Brave";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
142 |             "sec-ch-ua-mobile": "?0",
143 |             "sec-ch-ua-platform": '"Windows"',
144 |             "Sec-Fetch-Dest": "iframe",
145 |             "Sec-Fetch-Mode": "navigate",
146 |             "Sec-Fetch-Site": "cross-site",
147 |             "Sec-GPC": "1",
148 |             "Upgrade-Insecure-Requests": "1",
149 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
150 |         }
151 |         response = requests.get(url, headers=headers)
152 |         return response.text
153 | 
154 |     def rcp_verify(self, referer, token):
155 |         url = "https://vidsrc.stream/rcp_verify"
156 |         headers = {
157 |             "Accept": "*/*",
158 |             "Accept-Language": "en-GB,en;q=0.6",
159 |             "Connection": "keep-alive",
160 |             "Content-Length": "544",
161 |             "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
162 |             "Host": "vidsrc.stream",
163 |             "Origin": "https://vidsrc.stream",
164 |             "Referer": referer,
165 |             "sec-ch-ua": '"Brave";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
166 |             "sec-ch-ua-mobile": "?0",
167 |             "sec-ch-ua-platform": '"Windows"',
168 |             "Sec-Fetch-Dest": "empty",
169 |             "Sec-Fetch-Mode": "cors",
170 |             "Sec-Fetch-Site": "same-origin",
171 |             "Sec-GPC": "1",
172 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
173 |             "X-Requested-With": "XMLHttpRequest"
174 |         }
175 | 
176 |         data = {"token": token}
177 |         response = requests.post(url, data=data, headers=headers)
178 |         if response.status_code == 200:
179 |             result = response.text
180 |             print(result)
181 |             if result == "1":
182 |                 print("Captcha solved successfully!")
183 |                 return True
184 |             else:
185 |                 print("Result length is not 1, scraping failed.")
186 |                 return False
187 |         else:
188 |             print("Failed to make POST request:", response.status_code)
189 | 
190 | 
191 | # scraper = Vidsrc()
192 | # response_data = scraper.fetch_sources(tmdb_id="1399", season="1", episode="1")
193 | # print(f"URL: {response_data}")
194 | 


--------------------------------------------------------------------------------
/scrapers/vixcloud.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | from bs4 import BeautifulSoup
  3 | import json
  4 | import re
  5 | 
  6 | class VixCloud:
  7 |     def __init__(self):
  8 |         self.base_url = "https://streamingcommunity.report"
  9 |         self.headers = {
 10 |             'Accept': 'text/html, application/xhtml+xml',
 11 |             'Accept-Language': 'en-GB,en;q=0.8',
 12 |             'Connection': 'keep-alive',
 13 |             'Content-Type': 'application/json',
 14 |             'Host': 'streamingcommunity.report',
 15 |             'sec-ch-ua': '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
 16 |             'sec-ch-ua-mobile': '?0',
 17 |             'sec-ch-ua-platform': '"Windows"',
 18 |             'Sec-Fetch-Dest': 'empty',
 19 |             'Sec-Fetch-Mode': 'cors',
 20 |             'Sec-Fetch-Site': 'same-origin',
 21 |             'Sec-GPC': '1',
 22 |             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
 23 |         }
 24 |         self.xsrf_token, self.session_cookie = self.fingerprint()
 25 | 
 26 |     def search(self, query):
 27 |         url = f"{self.base_url}/search?q={query}"
 28 |         headers_search = {
 29 |             'X-Inertia': 'true',
 30 |             'X-Inertia-Version': '9f1517b00147fb7ff43b935a25c2b654',
 31 |             'X-Requested-With': 'XMLHttpRequest',
 32 |             'X-XSRF-TOKEN': self.xsrf_token,
 33 |         }
 34 |         try:
 35 |             response = requests.get(url, headers={**self.headers, **headers_search})
 36 |             response.raise_for_status()
 37 |             return response.json()['props']['titles'][0]['id']
 38 |         except requests.exceptions.RequestException as e:
 39 |             # print(f"Error sending request: {e}")
 40 |             return None
 41 | 
 42 |     def extract_video_info(self, html_content):
 43 |         soup = BeautifulSoup(html_content, 'html.parser')
 44 |         script_tag = soup.find('script', string=lambda s: s and 'window.masterPlaylist =' in s)
 45 | 
 46 |         if script_tag:
 47 |             script_content = script_tag.string
 48 |             match = re.search(r'window\.masterPlaylist\s*=\s*{[^}]*}', script_content, re.DOTALL)
 49 | 
 50 |             if match:
 51 |                 json_content = match.group(0).split('params:')[1]
 52 |                 params_json_content = re.sub(r'\s+', '', json_content)
 53 |                 json_content = params_json_content.replace("'", "\"")
 54 |                 json_content = re.sub(r',\s*}', '}', json_content)
 55 |                 try:
 56 |                     master_playlist_info = json.loads(json_content)
 57 |                     return master_playlist_info
 58 |                 except json.JSONDecodeError as e:
 59 |                     print(f"Error decoding JSON: {e}")
 60 |                     return None
 61 |             else:
 62 |                 print("Error extracting master playlist information.")
 63 |                 return None
 64 |         else:
 65 |             print("Script tag containing master playlist information not found.")
 66 |             return None
 67 | 
 68 |     def get_iframe_src(self, url):
 69 |         headers = {
 70 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 71 |             "Accept-Language": "en-GB,en;q=0.8",
 72 |             "Connection": "keep-alive",
 73 |             "Host": "vixcloud.co",
 74 |             "Referer": "https://streamingcommunity.report/",
 75 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
 76 |             "sec-ch-ua-mobile": "?0",
 77 |             "sec-ch-ua-platform": '"Windows"',
 78 |             "Sec-Fetch-Dest": "iframe",
 79 |             "Sec-Fetch-Mode": "navigate",
 80 |             "Sec-Fetch-Site": "cross-site",
 81 |             "Sec-GPC": "1",
 82 |             "Upgrade-Insecure-Requests": "1",
 83 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
 84 |         }
 85 | 
 86 |         response = requests.get(url, headers=headers)
 87 | 
 88 |         if response.status_code == 200:
 89 |             # print("Request successful")
 90 |             return response.text
 91 |         else:
 92 |             print(f"Request failed with status code {response.status_code}")
 93 |             return None
 94 | 
 95 |     def extract_iframe_src(self, html_content):
 96 |         soup = BeautifulSoup(html_content, 'html.parser')
 97 |         iframe_tag = soup.find('iframe', {'src': True})
 98 | 
 99 |         if iframe_tag:
100 |             return iframe_tag['src']
101 |         else:
102 |             return None
103 | 
104 |     def send_api_request(self, start_id):
105 |         url = f"https://streamingcommunity.report/iframe/{start_id}"
106 |         # print(url)
107 |         headers = {
108 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
109 |             "Accept-Language": "en-GB,en;q=0.8",
110 |             "Connection": "keep-alive",
111 |             "Host": "streamingcommunity.report",
112 |             "Referer": "https://streamingcommunity.report/watch/6814",
113 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
114 |             "sec-ch-ua-mobile": "?0",
115 |             "sec-ch-ua-platform": '"Windows"',
116 |             "Sec-Fetch-Dest": "empty",
117 |             "Sec-Fetch-Mode": "navigate",
118 |             "Sec-Fetch-Site": "same-origin",
119 |             "Sec-GPC": "1",
120 |             "Upgrade-Insecure-Requests": "1",
121 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
122 |         }
123 | 
124 |         headers["Cookie"] = f"XSRF-TOKEN={self.xsrf_token}; streamingcommunity_session={self.session_cookie}"
125 | 
126 |         response = requests.get(url, headers=headers)
127 | 
128 |         if response.status_code == 200:
129 |             # print("API Request successful")
130 |             return response.text
131 |         else:
132 |             print(f"API Request failed with status code {response.status_code}")
133 |             return None
134 | 
135 |     def fingerprint(self):
136 |         url = "https://streamingcommunity.report/watch/6814"
137 |         headers = {
138 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
139 |             "Accept-Encoding": "gzip, deflate, br",
140 |             "Accept-Language": "en-GB,en;q=0.8",
141 |             "Connection": "keep-alive",
142 |             "Host": "streamingcommunity.report",
143 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
144 |             "sec-ch-ua-mobile": "?0",
145 |             "sec-ch-ua-platform": '"Windows"',
146 |             "Sec-Fetch-Dest": "empty",
147 |             "Sec-Fetch-Mode": "navigate",
148 |             "Sec-Fetch-Site": "same-origin",
149 |             "Sec-GPC": "1",
150 |             "Upgrade-Insecure-Requests": "1",
151 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
152 |         }
153 | 
154 |         response = requests.get(url, headers=headers)
155 | 
156 |         if response.status_code == 200:
157 |             # print("Fingerprinting successful")
158 | 
159 |             xsrf_token_cookie = response.cookies.get("XSRF-TOKEN")
160 |             streamingcommunity_session_cookie = response.cookies.get("streamingcommunity_session")
161 | 
162 |             # print(f"XSRF-TOKEN: {xsrf_token_cookie}")
163 |             # print(f"streamingcommunity_session: {streamingcommunity_session_cookie}")
164 | 
165 |             return xsrf_token_cookie, streamingcommunity_session_cookie
166 |         else:
167 |             print(f"Request failed with status code {response.status_code}")
168 |             return None, None
169 | 
170 |     def construct_video_url(self, base_url, video_info):
171 |         url = f"{base_url}?token={video_info['token']}&token480p={video_info['token480p']}&token720p={video_info['token720p']}&token1080p={video_info['token1080p']}&expires={video_info['expires']}"
172 |         return url
173 | 
174 |     def fetch_sources(self, tmdb_id):
175 |         start_id = self.search(str(tmdb_id))
176 |         response_data = self.send_api_request(start_id)
177 |         iframe = self.extract_iframe_src(response_data)
178 |         videoid = iframe.split('/embed/')[1].split('?')[0]
179 |         response_html = self.get_iframe_src(iframe)
180 |         stream_info = self.extract_video_info(response_html)
181 |         video_url = self.construct_video_url(f'https://vixcloud.co/playlist/{videoid}', stream_info)
182 |         return video_url
183 | 
184 | 
185 | # Example usage:
186 | # scraper = VixCloud()
187 | # response_data = scraper.fetch_sources("Barbie")
188 | # # print(f"Movie URL: {response_data}")
189 | 


--------------------------------------------------------------------------------
/scrapers/flixhq.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | from bs4 import BeautifulSoup
  3 | import re
  4 | 
  5 | # WARNING SOURCES ARE ENCRYPTED AND KEYS ARE IP LOCKED SO YOU NEED TO HOST YOUR OWN KEY EXTRACTOR ON THE SAME IP AS UR SCRAPER
  6 | 
  7 | class FlixHQMovies:
  8 |     def __init__(self):
  9 |         self.base_url = "https://flixhq.to"
 10 |         self.headers = {
 11 |             "Accept": "*/*",
 12 |             "accept-language": "en-GB,en;q=0.8",
 13 |             "Connection": "keep-alive",
 14 |             "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
 15 |             "Cookie": "prefetchAd_6186241=true; _ga_SLT5RHZ3PC=GS1.1.1708987327.1.0.1708987327.0.0.0; _ga=GA1.1.1942035551.1708987327",
 16 |             "Host": "flixhq.to",
 17 |             "Origin": "https://flixhq.to",
 18 |             "Referer": "https://flixhq.to/",
 19 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
 20 |             "sec-ch-ua-mobile": "?0",
 21 |             "sec-ch-ua-platform": '"Windows"',
 22 |             "Sec-Fetch-Dest": "empty",
 23 |             "Sec-Fetch-Mode": "cors",
 24 |             "Sec-Fetch-Site": "same-origin",
 25 |             "Sec-GPC": "1",
 26 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
 27 |             "X-Requested-With": "XMLHttpRequest"
 28 |         }
 29 | 
 30 |     def make_post_request(self, keyword):
 31 |         url = f"{self.base_url}/ajax/search"
 32 |         data = {"keyword": keyword}
 33 |         response = requests.post(url, headers=self.headers, data=data)
 34 |         if response.status_code == 200:
 35 |             return response.text
 36 |         else:
 37 |             return f"Failed to fetch data: {response.status_code}"
 38 | 
 39 |     def get_upcloud_and_vidcloud_id(self, id):
 40 |         url = f"{self.base_url}/ajax/episode/list/{id}"
 41 |         response = requests.get(url, headers=self.headers)
 42 |         if response.status_code == 200:
 43 |             return response.text
 44 |         else:
 45 |             return f"Failed to fetch data: {response.status_code}"
 46 | 
 47 |     def get_rabbitstream_embed(self, id):
 48 |         url = f"{self.base_url}/ajax/episode/sources/{id}"
 49 |         response = requests.get(url, headers=self.headers)
 50 |         if response.status_code == 200:
 51 |             return response.json()
 52 |         else:
 53 |             return f"Failed to fetch data: {response.status_code}"
 54 | 
 55 |     def extract_number_from_url(self, url):
 56 |         return re.search(r'\d+$', url).group()
 57 | 
 58 | 
 59 | 
 60 |     def fetch_source_data(self, id):
 61 |         url = f"https://rabbitstream.net/ajax/v2/embed-4/getSources?id={id}&v=30061&h=cee6762ddfab4706a1045c519fdbc047ed85a4fe&b=1878522368"
 62 |         headers = {
 63 |             "accept": "*/*",
 64 |             "accept-language": "en-GB,en;q=0.8",
 65 |             "sec-ch-ua": "\"Not A(Brand\";v=\"99\", \"Brave\";v=\"121\", \"Chromium\";v=\"121\"",
 66 |             "sec-ch-ua-mobile": "?1",
 67 |             "sec-ch-ua-platform": "\"Android\"",
 68 |             "sec-fetch-dest": "empty",
 69 |             "sec-fetch-mode": "cors",
 70 |             "sec-fetch-site": "same-site",
 71 |             "sec-gpc": "1",
 72 |             "Host": "rabbitstream.net",
 73 |             "Referer": f"https://rabbitstream.net/v2/embed-4/{id}?z=",
 74 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
 75 |             "X-Requested-With": "XMLHttpRequest"
 76 |         }
 77 | 
 78 |         response = requests.get(url, headers=headers)
 79 | 
 80 |         if response.status_code == 200:
 81 |             return response.json()  # If the response is JSON
 82 |         else:
 83 |             return "Failed to fetch data: " + str(response.status_code)
 84 | 
 85 |     def fetch_sources(self, keyword):
 86 |         def extract_id_from_link(link):
 87 |           if "rabbitstream.net" in link:
 88 |               start_index = link.find("/embed-4/") + len("/embed-4/")
 89 |               end_index = link.find("?z=")
 90 |               if start_index != -1 and end_index != -1:
 91 |                   return link[start_index:end_index]
 92 |           return None
 93 |         response_data = self.make_post_request(keyword)
 94 |         soup = BeautifulSoup(response_data, 'html.parser')
 95 |         first_url = soup.find('a', class_='nav-item')['href']
 96 |         number = self.extract_number_from_url(first_url)
 97 |         get_ids_content = self.get_upcloud_and_vidcloud_id(number)
 98 |         soup = BeautifulSoup(get_ids_content, 'html.parser')
 99 |         links = soup.find_all('a', class_='nav-link')
100 |         numbers = [self.extract_number_from_url(link['href']) for link in links]
101 |         sources = []
102 |         for number in numbers:
103 |             response_data = self.get_rabbitstream_embed(number)
104 |             # print(response_data)
105 |             rabbitstream_id = extract_id_from_link(response_data["link"])
106 |             resp = self.fetch_source_data(rabbitstream_id)
107 |             # print(resp)
108 |             sources.append(resp)
109 |         return sources
110 | 
111 | 
112 | class FlixHQTvShows:
113 |   def __init__(self):
114 |       self.headers = {
115 |           "Accept": "*/*",
116 |           "accept-language": "en-GB,en;q=0.8",
117 |           "Connection": "keep-alive",
118 |           "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
119 |           "Cookie": "prefetchAd_6186241=true; _ga_SLT5RHZ3PC=GS1.1.1708987327.1.0.1708987327.0.0.0; _ga=GA1.1.1942035551.1708987327",
120 |           "Host": "flixhq.to",
121 |           "Origin": "https://flixhq.to",
122 |           "Referer": "https://flixhq.to/",
123 |           "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
124 |           "sec-ch-ua-mobile": "?0",
125 |           "sec-ch-ua-platform": '"Windows"',
126 |           "Sec-Fetch-Dest": "empty",
127 |           "Sec-Fetch-Mode": "cors",
128 |           "Sec-Fetch-Site": "same-origin",
129 |           "Sec-GPC": "1",
130 |           "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
131 |           "X-Requested-With": "XMLHttpRequest"
132 |       }
133 | 
134 |   def make_post_request(self, keyword):
135 |       url = "https://flixhq.to/ajax/search"
136 |       data = {"keyword": keyword}
137 |       response = requests.post(url, headers=self.headers, data=data)
138 |       if response.status_code == 200:
139 |           return response.text
140 |       else:
141 |           return f"Failed to fetch data: {response.status_code}"
142 | 
143 |   def get_upcloud_and_vidcloud_id(self, id):
144 |       url = f"https://flixhq.to/ajax/season/list/{id}"
145 |       response = requests.get(url, headers=self.headers)
146 |       if response.status_code == 200:
147 |           return response.text
148 |       else:
149 |           return f"Failed to fetch data: {response.status_code}"
150 | 
151 |   def get_episodes(self, id):
152 |       url = f"https://flixhq.to/ajax/season/episodes/{id}"
153 |       response = requests.get(url, headers=self.headers)
154 |       if response.status_code == 200:
155 |           return response.text
156 |       else:
157 |           return f"Failed to fetch data: {response.status_code}"
158 | 
159 |   def get_episode_servers(self, id):
160 |       url = f"https://flixhq.to/ajax/episode/servers/{id}"
161 |       response = requests.get(url, headers=self.headers)
162 |       if response.status_code == 200:
163 |           return response.text
164 |       else:
165 |           return f"Failed to fetch data: {response.status_code}"
166 | 
167 |   def get_rabbitstream_embed(self, id):
168 |       url = f"https://flixhq.to/ajax/episode/sources/{id}"
169 |       response = requests.get(url, headers=self.headers)
170 |       if response.status_code == 200:
171 |           return response.json()
172 |       else:
173 |           return f"Failed to fetch data: {response.status_code}"
174 | 
175 |   def fetch_source_data(self, link):
176 |       # Function to extract ID from the link
177 |       def extract_id_from_link(link):
178 |           if "rabbitstream.net" in link:
179 |               start_index = link.find("/embed-4/") + len("/embed-4/")
180 |               end_index = link.find("?z=")
181 |               if start_index != -1 and end_index != -1:
182 |                   return link[start_index:end_index]
183 |           return None
184 | 
185 |       # Extract ID from the link
186 |       id = extract_id_from_link(link)
187 | 
188 |       # If ID is extracted successfully
189 |       if id:
190 |             url = f"https://rabbitstream.net/ajax/v2/embed-4/getSources?id={id}&v=30061&h=cee6762ddfab4706a1045c519fdbc047ed85a4fe&b=1878522368"
191 |             headers = {
192 |                 "accept": "*/*",
193 |                 "accept-language": "en-GB,en;q=0.8",
194 |                 "sec-ch-ua": "\"Not A(Brand\";v=\"99\", \"Brave\";v=\"121\", \"Chromium\";v=\"121\"",
195 |                 "sec-ch-ua-mobile": "?1",
196 |                 "sec-ch-ua-platform": "\"Android\"",
197 |                 "sec-fetch-dest": "empty",
198 |                 "sec-fetch-mode": "cors",
199 |                 "sec-fetch-site": "same-site",
200 |                 "sec-gpc": "1",
201 |                 "Host": "rabbitstream.net",
202 |                 "Referer": f"https://rabbitstream.net/v2/embed-4/{id}?z=",
203 |                 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
204 |                 "X-Requested-With": "XMLHttpRequest"
205 |             }
206 | 
207 | 
208 |             response = requests.get(url, headers=headers)
209 | 
210 |             if response.status_code == 200:
211 |                 return response.json()  # If the response is JSON
212 |             else:
213 |                 return f"Failed to fetch data: {response.status_code}"
214 |       else:
215 |           return "Failed to extract ID from the link"
216 | 
217 |   def fetch_sources(self, keyword, season, episode):
218 |       response_data = self.make_post_request(keyword)
219 |       soup = BeautifulSoup(response_data, 'html.parser')
220 |       first_url = soup.find('a', class_='nav-item')['href']
221 |       number = re.search(r'\d+$', first_url).group()
222 | 
223 |       get_ids_content = self.get_upcloud_and_vidcloud_id(number)
224 |       soup = BeautifulSoup(get_ids_content, 'html.parser')
225 |       season_links = soup.find_all('a', class_='ss-item')
226 |       season_ids = {}
227 |       for link in season_links:
228 |           season_id = link['data-id']
229 |           season_number = link.text.strip().split()[-1]
230 |           season_ids[season_number] = season_id
231 | 
232 |       season_id = season_ids[str(season)]
233 |       episodes_content = self.get_episodes(season_id)
234 |       soup = BeautifulSoup(episodes_content, 'html.parser')
235 |       episode_links = soup.find_all('a', class_='eps-item')
236 |       episode_info = {}
237 |       for link in episode_links:
238 |           episode_id = link['data-id']
239 |           episode_title = link.text.strip()
240 |           episode_number = episode_title.split(':')[0].split()[-1]
241 |           episode_info[episode_number] = episode_id
242 | 
243 |       episode_id = episode_info[str(episode)]
244 |       episode_servers_content = self.get_episode_servers(episode_id)
245 |       soup = BeautifulSoup(episode_servers_content, 'html.parser')
246 |       link_items = soup.find_all('a', class_='link-item')
247 |       server_ids = []
248 |       for item in link_items:
249 |           server_id = item['data-id']
250 |           server_ids.append(server_id)
251 | 
252 |       sources = []
253 |       for server_id in server_ids:
254 |           rabbitstream_embed_content = self.get_rabbitstream_embed(server_id)
255 |           res = self.fetch_source_data(rabbitstream_embed_content["link"])
256 |           sources.append(res)
257 | 
258 |       return sources
259 | 
260 | 
261 | 
262 | 


--------------------------------------------------------------------------------
/scrapers/unfinished/uhdmovies.py:
--------------------------------------------------------------------------------
  1 | # No movie fetching logic yet- just the redirect scraper
  2 | # Starting to clean up code
  3 | 
  4 | import requests
  5 | from bs4 import BeautifulSoup
  6 | import re
  7 | from urllib.parse import quote
  8 | 
  9 | class UHDRedirectScraper:
 10 |     def __init__(self):
 11 |         pass
 12 | 
 13 |     @staticmethod
 14 |     def parse_redirect_page(html):
 15 |         pattern = r'<meta\s+http-equiv="refresh"\s+content="0;url=(.*?)"\s*/?>'
 16 |         match = re.search(pattern, html)
 17 |         if match:
 18 |             redirect_url = match.group(1)
 19 |             return redirect_url
 20 |         else:
 21 |             return None
 22 | 
 23 |     @staticmethod
 24 |     def make_post_request(_wp_http):
 25 |         url = "https://tech.unblockedgames.world/"
 26 |         payload = {"_wp_http": _wp_http}
 27 |         headers = {
 28 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 29 |             "Accept-Language": "en-GB,en;q=0.8",
 30 |             "Cache-Control": "max-age=0",
 31 |             "Connection": "keep-alive",
 32 |             "Content-Type": "application/x-www-form-urlencoded",
 33 |             "Host": "tech.unblockedgames.world",
 34 |             "Origin": "null",
 35 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
 36 |             "sec-ch-ua-mobile": "?0",
 37 |             "sec-ch-ua-platform": '"Windows"',
 38 |             "Sec-Fetch-Dest": "document",
 39 |             "Sec-Fetch-Mode": "navigate",
 40 |             "Sec-Fetch-Site": "same-origin",
 41 |             "Sec-GPC": "1",
 42 |             "Upgrade-Insecure-Requests": "1",
 43 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
 44 |         }
 45 |         response = requests.post(url, data=payload, headers=headers)
 46 |         soup = BeautifulSoup(response.content, 'html.parser')
 47 |         form = soup.find('form', id='landing')
 48 |         action_url = form['action']
 49 |         _wp_http2 = form.find('input', {'name': '_wp_http2'})['value']
 50 |         token = form.find('input', {'name': 'token'})['value']
 51 |         return action_url, _wp_http2, token
 52 | 
 53 |     @staticmethod
 54 |     def get_pepe_url(action_url, _wp_http2, token):
 55 |         url = action_url
 56 |         payload = {"_wp_http2": _wp_http2, "token": token}
 57 |         headers = {
 58 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 59 |             "Accept-Language": "en-GB,en;q=0.8",
 60 |             "Cache-Control": "max-age=0",
 61 |             "Connection": "keep-alive",
 62 |             "Content-Type": "application/x-www-form-urlencoded",
 63 |             "Host": "tech.unblockedgames.world",
 64 |             "Origin": "https://tech.unblockedgames.world",
 65 |             "Referer": "https://tech.unblockedgames.world/",
 66 |             "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
 67 |             "sec-ch-ua-mobile": "?0",
 68 |             "sec-ch-ua-platform": '"Windows"',
 69 |             "Sec-Fetch-Dest": "document",
 70 |             "Sec-Fetch-Mode": "navigate",
 71 |             "Sec-Fetch-Site": "same-origin",
 72 |             "Sec-Fetch-User": "?1",
 73 |             "Sec-GPC": "1",
 74 |             "Upgrade-Insecure-Requests": "1",
 75 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
 76 |         }
 77 |         response = requests.post(url, data=payload, headers=headers)
 78 |         return response.text
 79 | 
 80 |     @staticmethod
 81 |     def get_match(resp):
 82 |         pattern = r'https://tech\.unblockedgames\.world/\?go=[^"]+'
 83 |         matches = re.findall(pattern, resp)
 84 |         return matches
 85 | 
 86 |     @staticmethod
 87 |     def make_get_request(url, cookies, ref):
 88 |         headers = {
 89 |             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
 90 |             "Accept-Language": "en-GB,en;q=0.8",
 91 |             "Connection": "keep-alive",
 92 |             "Host": "tech.unblockedgames.world",
 93 |             "Sec-Fetch-Dest": "document",
 94 |             "Sec-Fetch-Mode": "navigate",
 95 |             "Sec-Fetch-Site": "same-origin",
 96 |             "Sec-Fetch-User": "?1",
 97 |             "Sec-GPC": "1",
 98 |             "Upgrade-Insecure-Requests": "1",
 99 |             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
100 |             "Referrer": ref,
101 |             "Cookie": "; ".join([f"{key}={value}" for key, value in cookies.items()]),
102 |         }
103 |         response = requests.get(url, headers=headers, allow_redirects=True)
104 |         return response.text
105 | 
106 | # Example usage:
107 | url = "https://tech.unblockedgames.world/?sid=bnpxOTF5Uk9VOVFZM2lEMkxXUmp0Y1dhWTZGUU8vUkluNmtDZ0FITDhrL0tBSDVUTEdWTmdBNnpPajczek1EQ2lkYXc1b0IzQTJnc1MrbUhRRjJ3cU1Nc0pEYXNuNmwwcmNzMDJRVHZhd1BNMmtpV1RrRHE0dGxML3hHZEhKaGFjN1g4VWsvai9DTkV3a0JCT01ZZENnazVrdk9WV0Ixa2xYTVVLUWQ0aGtBM3d1RHBDQnJ4ZGVWd2xNcDBrRTlJbFJsb2ExT3ArMVpkZWlTb3JiUVh3TTN4MzVubE5Tem9kcnJQYlNsVU80VnU1WCtuWG82Ry9Qcy9OK25tdWZHTA=="
108 | _wp_http = url.split('?sid=')[1]
109 | scraper = UHDRedirectScraper()
110 | action_url, _wp_http2, token = scraper.make_post_request(_wp_http)
111 | print("Action URL:", action_url)
112 | print("_wp_http2:", _wp_http2)
113 | print("Token:", token)
114 | print()
115 | 
116 | resp = scraper.get_pepe_url(action_url, _wp_http2, token)
117 | matches = scraper.get_match(resp)
118 | print(matches)
119 | print()
120 | 
121 | pepe_url = matches[0]
122 | cookies = {
123 |     "__eoi": "ID=4a86dd07e2cfa744:T=1710970060:RT=1710970060:S=AA-AfjbVJgiJ3UbrHbBiGQPwwxlA",
124 |     "__qca": "P0-1796148875-1710970059080",
125 | }
126 | 
127 | if '?go=' in pepe_url:
128 |     key = str(pepe_url.split('?go=')[1])
129 |     cookies[key] = _wp_http2
130 | 
131 | print(cookies)
132 | response = scraper.make_get_request(pepe_url, cookies, action_url)
133 | final_url = scraper.parse_redirect_page(response)
134 | print(final_url)
135 | 
136 | def get_zfile(url):
137 |   headers = {
138 |       "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
139 |       "Accept-Language": "en-GB,en;q=0.8",
140 |       "Cache-Control": "max-age=0",
141 |       "Connection": "keep-alive",
142 |       "Content-Type": "application/x-www-form-urlencoded",
143 |       "Host": "driveleech.org",
144 |       "Origin": "https://driveleech.org",
145 |       "Referer": "https://driveleech.org/",
146 |       "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
147 |       "sec-ch-ua-mobile": "?0",
148 |       "sec-ch-ua-platform": '"Windows"',
149 |       "Sec-Fetch-Dest": "document",
150 |       "Sec-Fetch-Mode": "navigate",
151 |       "Sec-Fetch-Site": "same-origin",
152 |       "Sec-Fetch-User": "?1",
153 |       "Sec-GPC": "1",
154 |       "Upgrade-Insecure-Requests": "1",
155 |       "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
156 |   }
157 |   
158 |   driveleech = requests.get(final_url, headers=headers, allow_redirects=True)
159 |   
160 |   print(driveleech.text)
161 |   pattern = r'/file/([a-zA-Z0-9]+)'
162 | 
163 |   matches = re.search(pattern, driveleech.text)
164 | 
165 |   if matches:
166 |       file_id = matches.group(1)
167 |       print("File ID:", file_id)
168 |       return file_id
169 |   else:
170 |       print("File ID not found.")
171 |       return None
172 | 
173 | file_id = get_zfile(final_url)
174 | 
175 | def get_mkv(id):
176 |   headers = {
177 |       "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
178 |       "Accept-Language": "en-GB,en;q=0.8",
179 |       "Cache-Control": "max-age=0",
180 |       "Connection": "keep-alive",
181 |       "Content-Type": "application/x-www-form-urlencoded",
182 |       "Host": "driveleech.org",
183 |       "Origin": "https://driveleech.org",
184 |       "Referer": "https://driveleech.org/",
185 |       "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
186 |       "sec-ch-ua-mobile": "?0",
187 |       "sec-ch-ua-platform": '"Windows"',
188 |       "Sec-Fetch-Dest": "document",
189 |       "Sec-Fetch-Mode": "navigate",
190 |       "Sec-Fetch-Site": "same-origin",
191 |       "Sec-Fetch-User": "?1",
192 |       "Sec-GPC": "1",
193 |       "Upgrade-Insecure-Requests": "1",
194 |       "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
195 |   }
196 | 
197 |   driveleech = requests.get(f"https://driveleech.org/zfile/{id}", headers=headers, allow_redirects=True)
198 |   
199 |   
200 |   soup = BeautifulSoup(driveleech.text, 'html.parser')
201 |   links = soup.find_all('a', href=True)
202 |   print(links)
203 |   for link in links:
204 |       href_link = link['href']
205 |       if href_link.endswith(".mkv"):
206 |           print("Extracted Href Link ending in .mkv")
207 |         
208 |           url_safe = quote(href_link.split('/')[-1], safe='')
209 |           print("URL with spaces replaced by URL safe characters:")
210 |           print(href_link.replace(href_link.split('/')[-1], url_safe))
211 |           return href_link.replace(href_link.split('/')[-1], url_safe)
212 | 
213 | 
214 | def get_video_proxy(id):
215 |   headers = {
216 |       "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
217 |       "Accept-Language": "en-GB,en;q=0.8",
218 |       "Cache-Control": "max-age=0",
219 |       "Connection": "keep-alive",
220 |       "Content-Type": "application/x-www-form-urlencoded",
221 |       "Host": "driveleech.org",
222 |       "Origin": "https://driveleech.org",
223 |       "Referer": "https://driveleech.org/",
224 |       "sec-ch-ua": '"Chromium";v="122", "Not(A:Brand";v="24", "Brave";v="122"',
225 |       "sec-ch-ua-mobile": "?0",
226 |       "sec-ch-ua-platform": '"Windows"',
227 |       "Sec-Fetch-Dest": "document",
228 |       "Sec-Fetch-Mode": "navigate",
229 |       "Sec-Fetch-Site": "same-origin",
230 |       "Sec-Fetch-User": "?1",
231 |       "Sec-GPC": "1",
232 |       "Upgrade-Insecure-Requests": "1",
233 |       "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
234 |   }
235 | 
236 |   driveleech = requests.get(f"https://driveleech.org/file/{id}", headers=headers, allow_redirects=True)
237 | 
238 | 
239 |   soup = BeautifulSoup(driveleech.text, 'html.parser')
240 |   links = soup.find_all('a', href=True)
241 |   print(links)
242 |   for link in links:
243 |       href_link = link['href']
244 |       if href_link.startswith("https://video-proxy.xyz/"):
245 |           print("Extracted video-proxy url")
246 | 
247 | 
248 |           return href_link
249 | 
250 | 
251 | 
252 | import random
253 | import string
254 | 
255 | def generate_boundary():
256 |     return ''.join(random.choices(string.ascii_letters + string.digits, k=16))
257 | 
258 | def fetch_data_v(key):
259 |     url = "https://video-proxy.xyz/api"
260 | 
261 |     # Generate a random boundary string
262 |     boundary = generate_boundary()
263 | 
264 |     headers = {
265 |         "accept": "*/*",
266 |         "accept-language": "en-GB,en;q=0.6",
267 |         "content-type": f"multipart/form-data; boundary=----WebKitFormBoundary{boundary}",
268 |         "sec-ch-ua": "\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Brave\";v=\"122\"",
269 |         "sec-ch-ua-mobile": "?1",
270 |         "sec-ch-ua-platform": "\"Android\"",
271 |         "sec-fetch-dest": "empty",
272 |         "sec-fetch-mode": "cors",
273 |         "sec-fetch-site": "same-origin",
274 |         "sec-gpc": "1",
275 |         "x-token": "video-proxy.xyz",
276 |         "Referer": f"https://video-proxy.xyz/?url={key}",
277 |         "Referrer-Policy": "strict-origin-when-cross-origin"
278 |     }
279 |     body = {
280 |         "keys": key
281 |     }
282 | 
283 |     response = requests.post(url, headers=headers, data=body)
284 | 
285 |     if response.status_code == 200:
286 |         return response.json()
287 |     else:
288 |         return None
289 |   
290 | res = get_mkv(file_id)
291 | if res is None:
292 |   print("No mkv found, trying Instant Download")
293 |   res = get_video_proxy(file_id)
294 |   if res is None:
295 |     print("No video proxy found")
296 |     res = None
297 |   else:
298 |     res = fetch_data_v(res.split('?url=')[1])
299 | 
300 | print(res)


--------------------------------------------------------------------------------