diff --git a/.dockerignore b/.dockerignore
index 93f76c2..d19710b 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,3 +1,5 @@
 public/
 .github/
-.git/
\ No newline at end of file
+.git/
+fireside-scraper
+scraped-data
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 941d8e7..33ad939 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,3 +15,7 @@ $RECYCLE.BIN/
 
 # Editor
 .idea
+.vscode
+
+# Ignore all the scraped data
+scraped-data
diff --git a/Makefile b/Makefile
index fca8af9..b28191c 100644
--- a/Makefile
+++ b/Makefile
@@ -5,4 +5,19 @@ build:
 	hugo -D
 
 run:
-	docker-compose up -d --build
\ No newline at end of file
+	docker-compose up -d --build jbsite
+
+# Clean the scraped data
+scrape-clean:
+	rm -r scraped-data && mkdir scraped-data
+
+# Execute scrapig all the data from fireside into scraped-data dir
+scrape: scrape-clean
+	docker-compose up -d --build fireside-scraper && \
+	docker-compose logs --no-log-prefix -f fireside-scraper
+
+# Copy contents of the scraped-data into the project
+scrape-copy:
+	./scrape-copy.sh && ./generate-guests-symlinks.sh
+
+scrape-full: scrape scrape-copy
diff --git a/README.md b/README.md
index 8f6f7e7..46b40c2 100644
--- a/README.md
+++ b/README.md
@@ -69,9 +69,50 @@ Deployment is done with Github Actions, see workflow file in `.github/workflows/
 At the moment it is only triggered when something in the `main` branch is changing, but it can also be set up to run at certain times.
 This would also enable scheduled publishing, since Hugo per default only build pages which have set `date` in frontmatter to <= `now`
 
+
+## Fireside Scraper
+
+The [fireside-scraper](./fireside-scraper/) is based on [JB Show Notes](https://github.com/selfhostedshow/show-notes) that was written by [ironicbadger](https://github.com/ironicbadger).
+
+It goes over all the JB firside shows and scrapes the episodes into the format that is expected by hugo for each episode (using [this template](./fireside-scraper/src/templates/episode.md.j2)).
+
+Besides the episodes it also scrapes and creates the json files for:
+
+- sponsors
+- hosts
+- guests (every host is symlinked into the [guests dir](./data/guests/) since a host of one show, could be a guest on an episode of a different show)
+
+There are makefile commands that should me used to run it.
+
+### Run the scraper
+
+The command below would build, and start up the container which would save all the data into `scraped-data` dir.
+
+```
+make scrape
+```
+
+The files are organised in the same way as the files in the root project. This makes it very trivial to just copy the contents of `scraped-data` over to the root dir of the repo to include all the scraped content. And it can be done with:
+
+```
+make scrape-copy
+```
+
+or you could just run the following to scrape and copy over the root dir all at once:
+
+```
+make scrape-full
+```
+
+### Configuring the scraper
+
+Configure the scraper by modifying this [config.yml file](./fireside-scraper/src/config.yml)
+
 ## Credits
 
-I took parts of the functionality from the Castanet Theme: https://github.com/mattstratton/castanet
+- I took parts of the functionality from the Castanet Theme: https://github.com/mattstratton/castanet
 Mainly the RSS feed generation and managing of hosts / guests.
 
+- [ironicbadger](https://github.com/ironicbadger) and [JB Show Notes](https://github.com/selfhostedshow/show-notes) project which was used as the base for the `fireside-scraper`
+
 Time spend so far: 13h
diff --git a/config.toml b/config.toml
index 3931d31..ea41a5e 100644
--- a/config.toml
+++ b/config.toml
@@ -1,4 +1,4 @@
-baseURL = 'https://jb.codefighters.net/'
+baseURL = 'http://localhost:1111/'
 languageCode = 'en-us'
 title = 'Jupiter Broadcasting'
 
diff --git a/data/guests/alex.json b/data/guests/alex.json
deleted file mode 100644
index ee7ce5e..0000000
--- a/data/guests/alex.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "username": "alex",
-    "name": "Alex Kretzschmar",
-    "bio": "Red Hatter. Drone Racer. Photographer. Dog lover.",
-    "avatar": "/images/guests/alex_kretzschmar.jpeg",
-    "twitter": "https://twitter.com/ironicbadger",
-    "homepage":"https://www.linuxserver.io/",
-    "linkedin":"https://www.linkedin.com/in/alex-kretzschmar/"
-}
diff --git a/docker-compose.yml b/docker-compose.yml
index 1a3731f..5c89148 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -8,3 +8,12 @@ services:
       context: .
     ports:
       - 1111:80
+  fireside-scraper:
+    user: 1000:1000
+    image: fireside-scraper
+    container_name: fireside-scraper
+    build:
+      context: ./fireside-scraper
+    volumes:
+      - ./scraped-data:/data
+      - ./data:/hugo-data:ro
diff --git a/fireside-scraper/Dockerfile b/fireside-scraper/Dockerfile
new file mode 100644
index 0000000..e6f7498
--- /dev/null
+++ b/fireside-scraper/Dockerfile
@@ -0,0 +1,10 @@
+FROM python:3.10-alpine
+
+RUN mkdir /data && chown -R 1000:1000 /data
+
+COPY ./src/ /
+RUN chown 1000:1000 /scraper.py
+RUN pip install -U -r requirements.txt
+
+USER 1000
+CMD [ "python3", "scraper.py" ]
\ No newline at end of file
diff --git a/fireside-scraper/src/config.yml b/fireside-scraper/src/config.yml
new file mode 100644
index 0000000..ebb5aac
--- /dev/null
+++ b/fireside-scraper/src/config.yml
@@ -0,0 +1,31 @@
+shows:
+  selfhosted:
+    fireside_url: https://selfhosted.show
+    header_image: /images/shows/selfhosted.png
+    acronym: SSH
+    name: Self-Hosted
+  coderradio:
+    fireside_url: https://coder.show
+    header_image: /images/shows/coderradio.png
+    acronym: CR
+    name: Coder Radio
+  linux-action-news:
+    fireside_url: https://linuxactionnews.com
+    header_image: /images/shows/linux-action-news.png
+    acronym: LAN
+    name: Linux Action News
+  linuxun:
+    fireside_url: https://linuxunplugged.com
+    header_image: /images/shows/linuxun.png
+    acronym: LUP
+    name: LINUX Unplugged
+  extras:
+    fireside_url: https://extras.show
+    header_image: /images/shows/extras.png
+    acronym: JE
+    name: Jupiter EXTRAS
+  officehours:
+    fireside_url: https://www.officehours.hair
+    header_image: /images/shows/officehours.png
+    acronym: JE
+    name: Office Hours
diff --git a/fireside-scraper/src/requirements.txt b/fireside-scraper/src/requirements.txt
new file mode 100644
index 0000000..71eb0eb
--- /dev/null
+++ b/fireside-scraper/src/requirements.txt
@@ -0,0 +1,7 @@
+beautifulsoup4==4.9.3
+requests==2.25.1
+jinja2==3.0.1
+pymdown-extensions==8.2
+html2text==2020.1.16
+pyyaml==5.4.1
+python-dateutil==2.8.2
\ No newline at end of file
diff --git a/fireside-scraper/src/scraper.py b/fireside-scraper/src/scraper.py
new file mode 100644
index 0000000..057de53
--- /dev/null
+++ b/fireside-scraper/src/scraper.py
@@ -0,0 +1,439 @@
+import concurrent.futures
+import json
+import operator
+import os
+from re import S
+from urllib.parse import urlparse
+
+import html2text
+import requests
+import yaml
+from bs4 import BeautifulSoup
+from dateutil.parser import parse as date_parse
+from jinja2 import Template
+
+DATA_ROOT_DIR = "/data"
+
+# Missing data found in a show. Used to scrape and/or create these files after the
+# episode files been created.
+MISSING_SPONSORS = {}
+MISSING_HOSTS = set()
+MISSING_GUESTS = set()
+
+
+with open("templates/episode.md.j2") as f:
+    TEMPLATE = Template(f.read())
+
+
+def log_warn(show, ep, msg):
+    print(f"WARN | {show} {ep} | {msg}")
+
+
+def mkdir_safe(directory):
+    try:
+        os.makedirs(directory)
+    except FileExistsError:
+        pass
+
+
+def get_list(soup, pre_title):
+    """
+    Blocks of links are preceded by a `p` saying what it is.
+    """
+    pre_element = soup.find("p", string=pre_title)
+    if pre_element is None:
+        return None
+    return pre_element.find_next_sibling("ul")
+
+
+def get_duration(seconds):
+    minutes, seconds = divmod(seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours:02}:{minutes:02}:{seconds:02}"
+
+
+def get_plain_title(title: str):
+    """
+    Get just the show title, without any numbering etc
+    """
+    # Remove number before colon
+    title = title.split(":", 1)[-1]
+
+    # Remove data after the pipe
+    title = title.rsplit("|", 1)[0]
+
+    # Strip any stray spaces
+    return title.strip()
+
+
+def create_episode(api_episode, show_config, hugo_data, output_dir):
+    try:
+        mkdir_safe(output_dir)
+
+        # RANT: What kind of API doesn't give the episode number?!
+        episode_number = int(api_episode["url"].split("/")[-1])
+        episode_number_padded = f"{episode_number:03}"
+
+        output_file = f"{output_dir}/{episode_number}.md"
+
+        if os.path.isfile(output_file):
+            print("Skipping", api_episode['url'], "as it already exists")
+            return
+
+        publish_date = date_parse(api_episode['date_published'])
+
+        api_soup = BeautifulSoup(api_episode["content_html"], "html.parser")
+        page_soup = BeautifulSoup(requests.get(
+            api_episode["url"]).content, "html.parser")
+
+        blurb = api_episode["summary"]
+
+        sponsors = parse_sponsors(
+            hugo_data, api_soup, page_soup, show_config["acronym"], episode_number)
+
+        links = html2text.html2text(
+            str(get_list(api_soup, "Links:") or get_list(api_soup, "Episode Links:")))
+
+        tags = []
+        for link in page_soup.find_all("a", class_="tag"):
+            tags.append(link.get_text().strip())
+
+        tags = sorted(tags)
+
+        hosts = parse_hosts(hugo_data, page_soup,
+                            show_config, episode_number)
+
+        guests = parse_guests(hugo_data, page_soup,
+                            show_config, episode_number)
+
+        show_attachment = api_episode["attachments"][0]
+
+        output = TEMPLATE.render(
+            {
+                # "title": api_episode["title"],
+                "title_plain": get_plain_title(api_episode["title"]),
+                "blurb": blurb,
+                "date_published": publish_date.date().isoformat(),
+                "is_draft": "false",
+                # TODO: In what case should the "Featured" category be added?
+                "categories": [show_config["name"]],
+                "tags": tags,
+                "hosts": hosts,
+                "guests": guests,
+                "sponsors": sponsors,
+                "header_image": show_config["header_image"],
+
+                "episode_number": episode_number,
+                "episode_number_padded": episode_number_padded,
+                "podcast_duration": get_duration(int(show_attachment['duration_in_seconds'])),
+                # TODO: the url in fireside is prefixed using https://chtbl.com not http://www.podtrac.com. Should this be left as is or changed to use podtrac?
+                "podcast_file": show_attachment["url"],
+                "podcast_bytes": show_attachment["size_in_bytes"],
+                # "url": api_episode["url"],
+
+                "youtube_link": "",  # TODO: leave empty or use None?
+                "video_file": "",  # TODO: leave empty or use None?
+                "links": links
+            }
+        )
+
+        with open(output_file, "w") as f:
+            print("Saving", api_episode["url"])
+            f.write(output)
+            
+    except Exception as e:
+        print(f"ERROR | Failed to create an episode from url `{api_episode.get('url')}`. Exception: {e}")
+
+def parse_hosts(hugo_data, page_soup: BeautifulSoup, show_config, ep):
+    show = show_config["acronym"]
+    base_url = show_config["fireside_url"]
+
+    hosts = []
+
+    # assumes the hosts are ALWAYS the first <ul> and guests are in the second one
+    hosts_links = page_soup.find("ul", class_="episode-hosts").find_all("a")
+
+    # hosts_links = page_soup.select(".episode-hosts ul:first-child a")
+    for link in hosts_links:
+        try:
+            host_name = link.get("title").strip()
+
+            host = hugo_data["hosts"]["_data"].get(host_name)
+            if host:
+                hosts.append(host["username"])
+            else:
+                log_warn(show, ep, f"Missing HOST definition for `{host_name}`")
+                host_page_url = base_url + link.get("href")
+                MISSING_HOSTS.add(host_page_url)
+                hosts.append(get_username_from_url(host_page_url))
+        except Exception as e:
+            print(f"ERROR | {show} {ep} | Failed to parse host for link href `{link.get('href')}`. Exception: {e}")
+    return hosts
+
+
+def parse_guests(hugo_data, page_soup, show_config, ep):
+    show = show_config["acronym"]
+    base_url = show_config["fireside_url"]
+
+    guests = []
+
+    # assumes the hosts are ALWAYS the first <ul> and guests are in the second one
+    hosts_list = page_soup.find("ul", class_="episode-hosts")  # <- this would always be the hosts list
+    # look for the NEXT `ul.episode-hosts`, that should be the guests list (might not exist)
+    guests_list = hosts_list.find_next("ul", class_="episode-hosts")
+    if not guests_list:
+        return guests
+    
+    guests_links = guests_list.find_all("a")
+    for link in guests_links:
+        try:
+            guest_name = link.get("title").strip()
+
+            guest = hugo_data["guests"]["_data"].get(guest_name)
+            # Sometimes the guests are already defined in the hosts, for example if they
+            # are hosts in a different show. So try to find the within hosts.
+            host_guest = hugo_data["hosts"]["_data"].get(guest_name)
+
+            if guest:
+                guests.append(guest["username"])
+            elif host_guest:
+                guests.append(host_guest["username"])
+            else:
+                log_warn(show, ep, f"Missing GUEST definition for `{guest_name}`")
+                guest_page_url = base_url + link.get("href")
+                MISSING_GUESTS.add(guest_page_url)
+                guests.append(get_username_from_url(guest_page_url))
+        
+        except Exception as e:
+            print(f"ERROR | {show} {ep} | Failed to parse episode guest for link href `{link.get('href')}`. Exception: {e}")
+        
+
+    return guests
+
+
+def parse_sponsors(hugo_data, api_soup, page_soup, show, ep):
+    # Get only the links of all the sponsors
+    sponsors_ul = get_list(api_soup, "Sponsored By:")
+    if not sponsors_ul:
+        log_warn(show, ep, "No sponsors found for this episode")
+        return []
+
+    sponsors_links = [a["href"]
+                      for a in sponsors_ul.select('li > a:first-child')]
+
+    sponsors = []
+    for sl in sponsors_links:
+        try:
+            s = hugo_data["sponsors"]["_data"].get(sl)
+            if s:
+                sponsors.append(s["shortname"])
+            else:
+                log_warn(show, ep, f"Missing SPONSOR definition for `{sl}`")
+
+                # Very ugly but works. The goal is to get the hostname of the sponsor link
+                # without the subdomain. It would fail on tlds like "co.uk" - But I don't
+                # think JB had any sponsors like that so it's fine.
+                sponsor_slug = ".".join(urlparse(sl).hostname.split(".")[-2:])
+                shortname = f"{sponsor_slug}-{show}".lower()
+                sponsors.append(shortname)
+
+                filename = f"{shortname}.json"
+
+                # Find the <a> element on the page with the link
+                sponsor_a = page_soup.find("div", class_="episode-sponsors").find("a", attrs={"href": sl})
+                if sponsor_a:
+                    MISSING_SPONSORS.update({
+                        filename: {
+                            "shortname": shortname,
+                            "name": sponsor_a.find("header").text.strip(),
+                            "description": sponsor_a.find("p").text.strip(),
+                            "link": sl
+                        }
+                    })
+        except Exception as e:
+            print(f"ERROR | {show} {ep} | Failed to collect/parse sponsor data for `{sl}`! Exception: {e}")
+
+    return sponsors
+
+
+def save_json_file(filename, json_obj, dest_dir):
+    mkdir_safe(dest_dir)
+
+    file_path = os.path.join(dest_dir, filename)
+
+    with open(file_path, "w") as f:
+        f.write(json.dumps(json_obj, indent=4))
+
+    print(f"Saved new json file `{file_path}`")
+
+
+def read_hugo_data():
+    hugo_data = {
+        "guests": {
+            "_key": "name",
+            "_data": {}
+        },
+        "hosts": {
+            "_key": "name",
+            "_data": {}
+        },
+        "sponsors": {
+            "_key": "link",
+            "_data": {}
+        }
+    }
+
+    for key, item in hugo_data.items():
+        files_dir = f"/hugo-data/{key}"
+        json_files = os.listdir(files_dir)
+
+        for file in json_files:
+            file_path = f"{files_dir}/{file}"
+            with open(file_path, "r") as f:
+                json_data = json.loads(f.read())
+                data_key = json_data.get(item["_key"])
+
+                if not data_key:
+                    print(f"read_hugo_data: skipping file `{file_path}` since it "
+                          "doesn't have the expected key `{item._key}`")
+                    continue
+
+                item["_data"].update({data_key: json_data})
+
+    hugo_data_debug = json.dumps(hugo_data, indent=2)
+    print(f"read_hugo_data: {hugo_data_debug}")
+
+    return hugo_data
+
+def get_username_from_url(url):
+    """
+    Get the last path part of the url which is the username for the hosts and guests
+    """
+    return urlparse(url).path.split("/")[-1]
+
+def create_host_or_guest(url, dirname):
+    try:
+        valid_dirnames = {"hosts", "guests"}
+        assert dirname in valid_dirnames, "dirname arg must be either `hosts` or `guests`"
+
+        page_soup = BeautifulSoup(requests.get(url).content, "html.parser")
+        
+        name = page_soup.find("h1").text.strip()
+
+        username = get_username_from_url(url)
+
+        # It's possible to replace url part "avatar_small.jpg" to "avatar.jpg" to get higher
+        # res img, but not sure if required.
+        avatar_url = page_soup.find("div", class_="hero-avatar").find("img").get("src")
+        resp = requests.get(avatar_url)
+        avatar_bytes = resp.content
+        file_ext = resp.headers.get("x-bz-file-name").split(".")[-1]
+
+        avatars_dir = os.path.join(DATA_ROOT_DIR, "static", "images", dirname)
+        mkdir_safe(avatars_dir)
+
+        filename = f"{username}.{file_ext}"
+        avatar_file = os.path.join(avatars_dir, filename)
+
+        with open(avatar_file, "wb") as f:
+            f.write(avatar_bytes)
+
+
+        # Get social links
+
+        homepage = None
+        twitter = None
+        linkedin = None
+        instagram = None
+        gplus = None
+        youtube = None
+        links = page_soup.find("nav", class_="links").find_all("a")
+
+        # NOTE: This will work only if none of the links are shortened urls
+        for link in links:
+            href = link.get("href").lower()
+            if "Website" in link.text:
+                homepage = href
+            elif "twitter" in href:
+                twitter = href
+            elif "linkedin" in href:
+                linkedin = href
+            elif "instagram" in href:
+                instagram = href
+            elif "google" in href:
+                gplus = href
+            elif "youtube" in href:
+                youtube = href
+
+        host_json = {
+            "username": username, # e.g. "alexktz"
+            "name": name, # e.g. "Alex Kretzschmar"
+            "bio":  page_soup.find("section").text.strip(), # e.g. "Red Hatter. Drone Racer. Photographer. Dog lover."
+            "avatar":  f"/images/{dirname}/{filename}", # e.g. "/images/guests/alex_kretzschmar.jpeg"
+            "homepage": homepage, # e.g. "https://www.linuxserver.io/"
+            "twitter": twitter, # e.g. "https://twitter.com/ironicbadger"
+            "linkedin": linkedin, # e.g. "https://www.linkedin.com/in/alex-kretzschmar/""
+            "instagram": instagram,
+            "gplus": gplus,
+            "youtube": youtube,
+        }
+
+        hosts_dir = os.path.join(DATA_ROOT_DIR, "data", dirname)
+        save_json_file(f"{username}.json", host_json, hosts_dir)
+    except Exception as e:
+        print(f"ERROR | Failed to create/save a new host/guest file from `{url}`. Exception: {e}")
+
+
+def main():
+    with open("config.yml") as f:
+        shows = yaml.load(f, Loader=yaml.SafeLoader)['shows']
+
+    hugo_data = read_hugo_data()
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = []
+        for show_slug, show_config in shows.items():
+            # Use same structure as in the root project for easy copy over
+            output_dir = os.path.join(
+                DATA_ROOT_DIR, "content", "show", show_slug)
+            mkdir_safe(output_dir)
+
+            api_data = requests.get(
+                show_config['fireside_url'] + "/json").json()
+
+            for idx, api_episode in enumerate(api_data["items"]):
+                futures.append(executor.submit(
+                    create_episode, api_episode, show_config, hugo_data, output_dir))
+
+        # Drain to get exceptions. This is important in order to collect all the
+        # MISSING_* globals first before proceeding
+        for future in concurrent.futures.as_completed(futures):
+            future.result()
+
+        # Now process the MISSING_* globals...
+
+        output_dir = os.path.join(DATA_ROOT_DIR, "data", "sponsors")
+        mkdir_safe(output_dir)
+
+        futures = []  # reset futures
+
+        # MISSING_SPONSORS:
+        for filename, sponsor in MISSING_SPONSORS.items():
+            futures.append(executor.submit(
+                save_json_file, filename, sponsor, output_dir))
+
+        # MISSING_HOSTS:
+        for url in MISSING_HOSTS:
+            futures.append(executor.submit(create_host_or_guest, url, "hosts"))
+
+        # MISSING_GUESTS:
+        for url in MISSING_GUESTS:
+            futures.append(executor.submit(create_host_or_guest, url, "guests"))
+
+        # Drain to get exceptions. Still have to mash CTRL-C, though.
+        for future in concurrent.futures.as_completed(futures):
+            future.result()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/fireside-scraper/src/templates/episode.md.j2 b/fireside-scraper/src/templates/episode.md.j2
new file mode 100644
index 0000000..1996649
--- /dev/null
+++ b/fireside-scraper/src/templates/episode.md.j2
@@ -0,0 +1,25 @@
++++
+title = "{{ title_plain }}"
+description = """{{ blurb }}"""
+date = "{{ date_published }}"
+draft = {{ is_draft }}
+categories = [{% for cat in categories %}"{{ cat }}"{% if not loop.last %},{% endif %}{% endfor %}]
+tags = [{% for tag in tags %}"{{ tag }}"{% if not loop.last %},{% endif %}{% endfor %}]
+hosts = [{% for host in hosts %}"{{ host }}"{% if not loop.last %},{% endif %}{% endfor %}]
+guests = [{% for guest in guests %}"{{ guest }}"{% if not loop.last %},{% endif %}{% endfor %}]
+sponsors = [{% for sponsor in sponsors %}"{{ sponsor }}"{% if not loop.last %},{% endif %}{% endfor %}]
+header_image = "{{ header_image }}"
+type = "episode"
+
+episode = {{ episode_number }}
+podcast_duration = "{{ podcast_duration }}"
+podcast_file = "{{ podcast_file }}"
+podcast_bytes = "{{ podcast_bytes }}"
+
+youtube_link = "{{ youtube_link }}"
+video_file = "{{ video_file }}"
++++
+
+## Episode links
+
+{{ links }}
diff --git a/generate-guests-symlinks.sh b/generate-guests-symlinks.sh
new file mode 100755
index 0000000..05ecb2f
--- /dev/null
+++ b/generate-guests-symlinks.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+echo "Generating symlinks for all hosts inside the guests dir..."
+
+# link json files
+cd data/guests
+ln -s ../hosts/* .
+
+# link avatar images
+cd ../../static/guests
+ln -s ../hosts/* .
+
+echo "Done."
\ No newline at end of file
diff --git a/scrape-copy.sh b/scrape-copy.sh
new file mode 100755
index 0000000..3c74c75
--- /dev/null
+++ b/scrape-copy.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+if [ -f scraped-data ]; then
+    echo "Copying scraped data into project root directory..."
+    cp -a scraped-data/* .
+    echo "Done."
+fi