| name | legal-downloading |
| description | Legal Downloading: Copyright-aware downloading, content that allows offline access, podcast tools, and compliance best practices |
| metadata | {"author":"cosmicstack-labs","version":"1.0.0","category":"media-download","tags":["legal-downloading","copyright-compliance","offline-access","podcast-tools","fair-use"]} |
Legal Downloading
Download media legally and responsibly. This skill covers the legal landscape of media downloading — what's allowed, what's not, and how to build workflows that respect copyright while still getting the content you need offline.
Core Principles
1. Copyright Is Not Optional
Copyright law protects creators' rights to control reproduction and distribution of their work. Downloading copyrighted content without permission is infringement in most jurisdictions, regardless of whether you're "just sharing" or "only for personal use."
2. Permission Comes in Many Forms
Not all downloading requires explicit permission. Look for:
- Explicit permission: Creative Commons, public domain, or direct creator authorization
- Implied permission: Platform download features, offline modes, RSS feeds
- Statutory permission: Fair use/fair dealing, time-shifting, format-shifting (jurisdiction-dependent)
3. Platform Terms Matter
Each platform has its own terms of service that govern what you can do with content. YouTube's Terms of Service prohibit downloading videos unless a download button or API is provided. Violating ToS isn't necessarily illegal, but it can get your account terminated.
4. Know Your Jurisdiction
Copyright law varies significantly by country. Fair use (US) is broader than fair dealing (UK, Canada, Australia). Private copying exceptions exist in some EU countries but not others. Know the laws that apply to you.
Understanding Copyright and Fair Use
What Copyright Protects
Copyright protects original works of authorship fixed in a tangible medium:
- Audiovisual works: Movies, TV shows, videos
- Sound recordings: Music, podcasts, audio books
- Literary works: Books, articles, code
- Musical works: Compositions, lyrics
Copyright grants the creator exclusive rights to:
- Reproduce the work
- Create derivative works
- Distribute copies
- Perform the work publicly
- Display the work publicly
Fair Use (US Law)
Fair use is a legal doctrine that permits limited use of copyrighted material without permission. Courts evaluate four factors:
| Factor | Favors Fair Use | Against Fair Use |
|---|
| Purpose of use | Education, research, criticism, news reporting, commentary | Commercial use, entertainment |
| Nature of work | Factual, published, non-fiction | Creative, unpublished, fiction |
| Amount used | Small portion, not the "heart" of the work | Large portion, entire work |
| Market effect | No harm to market, transformative | Replaces original, harms sales |
Important: Fair use is a defense, not a right. Only a court can definitively determine if a use is fair. There are no bright-line rules.
Fair Dealing (UK, Canada, Australia)
Similar to fair use but more narrowly defined. Specific categories include:
- Research and private study
- Criticism and review
- News reporting
- Education
- Parody and satire
Canada's Copyright Act includes a specific exception for format-shifting (making copies for personal use) and time-shifting (recording broadcasts for later viewing).
Private Copying Exceptions
Some countries allow limited private copying:
- EU: Article 5(2)(b) of the InfoSoc Directive allows member states to implement private copying exceptions
- Germany: Private copying is allowed with a levy on blank media
- Japan: Private copying is permitted for personal use
- Australia: Format-shifting for personal use is allowed
Tools for Legal Downloading
Spotify Offline Mode
YouTube Music Offline
Netflix Downloads
Amazon Prime Video Downloads
Podcast Downloading
Podcasts are one of the few content types where downloading is explicitly and universally permitted. RSS feeds are designed for open access and offline listening.
Using gPodder
pip install gpodder
gpo add "https://feeds.simplecast.com/XXXXX"
gpo list
gpo download
gpo download "Podcast Name"
gpo status
gpo update && gpo download
Using PodcastIndex API
import requests
import xml.etree.ElementTree as ET
class PodcastIndexClient:
"""
Client for the PodcastIndex API — an open, decentralized podcast directory.
Free to use with API key registration.
"""
def __init__(self, api_key, api_secret):
self.api_key = api_key
self.api_secret = api_secret
self.base_url = "https://api.podcastindex.org/api/1.0"
def search(self, query, max_results=10):
"""Search for podcasts by name or topic."""
headers = {
'X-Auth-Key': self.api_key,
'X-Auth-Secret': self.api_secret,
}
response = requests.get(
f"{self.base_url}/search/byterm",
params={'q': query, 'max': max_results},
headers=headers
)
response.raise_for_status()
return response.json().get('feeds', [])
def get_episodes(self, feed_id, max_episodes=20):
"""Get episodes for a specific podcast feed."""
headers = {
'X-Auth-Key': self.api_key,
'X-Auth-Secret': self.api_secret,
}
response = requests.get(
f"{self.base_url}/episodes/byfeedid",
params={: feed_id, : max_episodes},
headers=headers
)
response.raise_for_status()
response.json().get(, [])
():
os
urllib.parse urlparse
output_dir = os.path.expanduser(output_dir)
os.makedirs(output_dir, exist_ok=)
filename = os.path.basename(urlparse(episode_url).path)
filename:
filename =
filepath = os.path.join(output_dir, filename)
os.path.exists(filepath):
()
filepath
()
response = requests.get(episode_url, stream=)
response.raise_for_status()
(filepath, ) f:
chunk response.iter_content(chunk_size=):
chunk:
f.write(chunk)
()
filepath
client = PodcastIndexClient(api_key=, api_secret=)
results = client.search()
feed results:
()
RSS Feed Downloader
"""Download podcasts from any valid RSS feed."""
import feedparser
import requests
import os
from datetime import datetime
from pathlib import Path
class PodcastDownloader:
"""
Download podcast episodes from RSS feeds.
Tracks what's been downloaded and handles incremental updates.
"""
def __init__(self, output_dir="~/Podcasts"):
self.output_dir = os.path.expanduser(output_dir)
self.history_file = os.path.join(self.output_dir, ".download_history")
self.downloaded = self._load_history()
def _load_history(self):
"""Load download history from file."""
if os.path.exists(self.history_file):
with open(self.history_file, 'r') as f:
return set(line.strip() for line in f if line.strip())
return set()
def _save_history(self):
"""Save download history to file."""
os.makedirs(os.path.dirname(.history_file), exist_ok=)
(.history_file, ) f:
guid (.downloaded):
f.write()
():
feed = feedparser.parse(rss_url)
podcast_name = feed.feed.get(, )
podcast_dir = os.path.join(.output_dir, podcast_name)
os.makedirs(podcast_dir, exist_ok=)
new_count =
entry feed.entries:
new_count >= max_episodes:
guid = entry.get(, entry.get(, ))
guid .downloaded:
audio_url =
link entry.get(, []):
link.get(, ).startswith():
audio_url = link[]
audio_url:
pub_date = entry.get()
date_prefix = datetime(*pub_date[:]).strftime() pub_date
title = entry.get(, )
safe_title = .join(c c title c.isalnum() c ).rstrip()
filename =
filepath = os.path.join(podcast_dir, filename)
()
:
response = requests.get(audio_url, stream=, timeout=)
response.raise_for_status()
(filepath, ) f:
chunk response.iter_content():
chunk:
f.write(chunk)
.downloaded.add(guid)
new_count +=
()
Exception e:
()
._save_history()
()
new_count
dl = PodcastDownloader()
dl.download_feed()
Public Domain and Creative Commons Content
Sources of Free and Legal Content
Public Domain
Works in the public domain are free of copyright restrictions. You can download, modify, and share them freely.
Creative Commons
Creative Commons licenses let creators grant permissions in advance. Different CC licenses have different restrictions:
| License | Attribution Required | ShareAlike | NonCommercial | NoDerivatives |
|---|
| CC0 | No | No | No | No |
| CC BY | Yes | No | No | No |
| CC BY-SA | Yes | Yes | No | No |
| CC BY-NC | Yes | No | Yes | No |
| CC BY-NC-SA | Yes | Yes | Yes | No |
| CC BY-ND | Yes | No | No | Yes |
| CC BY-NC-ND | Yes | No | Yes | Yes |
Searching for CC Content
Internet Archive Downloading
pip install internetarchive
ia search "subject:music AND collection:etree"
ia download <identifier>
ia download <identifier> --format=MP3
ia download <identifier> --metadata --glob="*mp3"
ia metadata <identifier>
Python: Internet Archive Downloader
"""Search and download from Internet Archive."""
import requests
import os
from urllib.parse import urljoin
class InternetArchiveDownloader:
"""Download public domain and CC-licensed content from archive.org."""
BASE_URL = "https://archive.org"
def search(self, query, media_types=['audio', 'video', 'movies']):
"""Search the Internet Archive."""
params = {
'q': query,
'fl[]': ['identifier', 'title', 'description', 'downloads'],
'sort[]': ['downloads desc'],
'rows': 50,
'page': 1,
'output': 'json'
}
response = requests.get(
f"{self.BASE_URL}/advancedsearch.php",
params=params
)
response.raise_for_status()
data = response.json()
return data.get('response', {}).get('docs', [])
def get_download_urls(self, identifier):
"""Get available download formats for an item."""
response = requests.get(
f"{self.BASE_URL}/details/{identifier}",
params={: }
)
response.raise_for_status()
data = response.json()
files = data.get(, [])
downloads = []
f files:
name = f.get(, )
source = f.get(, )
format_type = f.get(, )
source == :
downloads.append({
: name,
: format_type,
: f.get(, ),
:
})
downloads
():
shutil
output_dir = os.path.expanduser(output_dir)
item_dir = os.path.join(output_dir, identifier)
os.makedirs(item_dir, exist_ok=)
downloads = .get_download_urls(identifier)
formats:
downloads = [d d downloads d[] formats]
()
d downloads:
filepath = os.path.join(item_dir, d[])
os.path.exists(filepath) os.path.getsize(filepath) > :
()
()
response = requests.get(d[], stream=)
response.raise_for_status()
(filepath, ) f:
response.raw.decode_content =
shutil.copyfileobj(response.raw, f)
()
():
unit [, , , ]:
bytes_val < :
bytes_val /=
ia = InternetArchiveDownloader()
results = ia.search()
r results[:]:
()
YouTube Terms of Service Compliance
What YouTube Allows
YouTube's Terms of Service explicitly prohibit downloading content unless a download button or API is provided on the platform.
Allowed downloading methods:
- YouTube Premium: Official offline downloads within the YouTube app
- YouTube Music Premium: Official offline music downloads
- YouTube Download button: For creators who enable it on their videos
- YouTube Data API: For metadata, not video files
What's restricted:
- Using third-party tools to download videos
- Circumventing YouTube's technical protection measures
- Downloading for redistribution
- Automated scraping at scale
Content That Explicitly Allows Downloading
Some YouTube creators enable the download feature on their videos:
Best Practices for YouTube Content
- Only download your own content: You own the copyright to videos you created. Downloading your own uploads is always allowed.
- Download with creator permission: If a creator explicitly says downloads are okay (in description, comments, or their website), you have permission.
- Use YouTube Premium: For personal offline viewing, YouTube Premium is the authorized method.
- Download Creative Commons videos: YouTube allows filtering by Creative Commons license. These videos have pre-granted permissions.
- Don't redistribute: Even if you download, don't re-upload or share the files. Link to the original instead.
- Respect view counts: Streaming contributes to creator revenue and analytics. When possible, stream rather than download.
Checking Download Permissions
License Detection Tool
"""Check if content is licensed for downloading."""
import requests
import re
from urllib.parse import urlparse
class LicenseChecker:
"""
Check if content has explicit permission for downloading
by analyzing license information, page metadata, and terms.
"""
OPEN_LICENSE_KEYWORDS = [
'creative commons', 'public domain', 'cc0', 'cc by',
'cc by-sa', 'cc by-nc', 'cc by-nc-sa', 'royalty-free',
'royalty free', 'no copyright', 'copyright waived',
'license-free', 'license free', 'open source music',
'open source audio', 'podcast license', 'attribution only',
'attribution 4.0', 'attribution 3.0', 'copyright free',
'download permitted', 'free download', 'free to download',
]
RESTRICTIVE_KEYWORDS = [
'all rights reserved', 'copyright ©', '©', 'do not download',
'no downloads allowed', 'download prohibited', 'copyright protected',
'unauthorized distribution', 'not for redistribution',
'streaming only', , ,
]
():
domain = urlparse(url).netloc.lower()
platform_check = ._check_platform(domain, url)
platform_check:
platform_check
:
response = requests.get(url, timeout=, headers={
:
})
text = response.text.lower()
keyword .OPEN_LICENSE_KEYWORDS:
keyword text:
{
: ,
: ,
: ,
:
}
keyword .RESTRICTIVE_KEYWORDS:
keyword text:
{
: ,
: ,
: ,
:
}
{
: ,
: ,
: ,
:
}
Exception e:
{
: ,
: ,
: ,
:
}
():
platform_rules = {
: {
: ,
: ,
: ,
:
},
: {
: ,
: ,
: ,
:
},
: {
: ,
: ,
: ,
:
},
: {
: ,
: ,
: ,
:
},
: {
: ,
: ,
: ,
:
},
}
key, info platform_rules.items():
key domain:
info
checker = LicenseChecker()
result = checker.check_url()
()
()
()
Attribution Requirements
How to Give Proper Attribution
When using Creative Commons or other open-licensed content, proper attribution is both a legal requirement and good practice.
The TASL Framework:
- Title: What is the work called?
- Author: Who created it?
- Source: Where can it be found?
- License: What license is it under?
Attribution Template
"Title of Work" by Author Name is licensed under CC BY 4.0.
Source: https://example.com/work
For Collections or Archives
This collection includes:
- "Sunset Overdrive" by Jane Smith (CC BY-NC 4.0) — https://example.com/sunset
- "Urban Jazz" by Carlos Rivera (CC BY-SA 4.0) — https://example.com/jazz
- "Ocean Waves" from FreeSound.org (CC0) — via freesound.org/s/12345
Automated License Tracking
"""Track licenses for downloaded content and generate attribution files."""
import json
import os
from datetime import datetime
class LicenseTracker:
"""
Track licenses for downloaded media and generate README attribution files.
"""
def __init__(self, archive_path="~/Media"):
self.archive_path = os.path.expanduser(archive_path)
self.license_file = os.path.join(self.archive_path, "LICENSES.json")
self.attributions = self._load_attributions()
def _load_attributions(self):
"""Load existing attribution data."""
if os.path.exists(self.license_file):
with open(self.license_file, 'r') as f:
return json.load(f)
return []
def add_entry(self, title, author, source, license_type,
file_path=None, notes=""):
"""Add a license entry for downloaded content."""
entry = {
'title': title,
'author': author,
'source': source,
'license': license_type,
: file_path,
: datetime.now().isoformat(),
: notes,
}
.attributions.append(entry)
._save()
()
():
os.makedirs(os.path.dirname(.license_file), exist_ok=)
(.license_file, ) f:
json.dump(.attributions, f, indent=)
():
output_path:
output_path = os.path.join(.archive_path, )
lines = [
,
,
,
,
,
]
by_license = {}
entry .attributions:
license_type = entry[]
license_type by_license:
by_license[license_type] = []
by_license[license_type].append(entry)
license_type, entries by_license.items():
lines.append()
entry entries:
lines.append(
)
entry.get():
lines.append()
lines.append()
(output_path, ) f:
f.write(.join(lines))
()
output_path
():
results = []
query = query.lower()
entry .attributions:
(query entry[].lower()
query entry[].lower()
query entry[].lower()):
results.append(entry)
results
tracker = LicenseTracker()
tracker.add_entry(
title=,
author=,
source=,
license_type=,
notes=
)
tracker.generate_readme()
Personal Use vs. Distribution
What's Personal Use?
Personal use generally means:
- Watching/listening yourself
- Within your household
- Not publicly performing or displaying
- Not sharing files with others
- Not uploading to other platforms
What Crosses the Line
These activities typically require additional permission:
- Sharing files with friends, family, or online
- Uploading to another platform or server
- Public performance: Playing in a business, event, or stream
- Derivative works: Editing, remixing, or sampling
- Commercial use: Using in a paid product or service
- Sublicensing: Allowing others to use the content
Self-Audit Checklist
## Download Legitimacy Self-Audit
### Before downloading, ask:
- [ ] Do I own the copyright to this content?
- [ ] Has the creator explicitly allowed downloading?
- [ ] Is this content under a Creative Commons or open license?
- [ ] Is this content in the public domain?
- [ ] Am I using a platform's official download feature?
- [ ] Is this a podcast available via RSS feed?
### If you answered NO to ALL of the above:
**Do not download without explicit permission.**
### If you answered YES to any:
- [ ] Am I downloading for personal use only?
- [ ] Will I refrain from redistributing this content?
- [ ] Will I give proper attribution if required?
- [ ] Am I complying with the specific license terms?
Skill Maturity Model
| Level | Knowledge | Compliance | Tools | Practice |
|---|
| 1: Unaware | No copyright understanding | Downloading anything | Any tool regardless of ToS | No attribution |
| 2: Informed | Knows copyright basics | Avoids obvious infringement | Podcast apps, official download tools | Basic attribution |
| 3: Compliant | Understands licenses | Only downloads permitted content | License checkers, CC search | Proper TASL attribution |
| 4: Advocate | Deep license knowledge | Proactive compliance | Automated license tracking | Full license documentation |
| 5: Steward | Legal nuance mastery | Educator + policy maker | License management systems | Community education |
Target: Level 3 for everyday use. Level 4 for content creators and curators. Level 5 for organizations managing media at scale.
Common Mistakes
- Assuming "for personal use" is always legal: In many jurisdictions, personal use is not a blanket exception. Making copies — even for yourself — of copyrighted content without permission is still infringement in most countries.
- Confusing "free to access" with "free to download": Streaming content without paying doesn't mean downloading is allowed. YouTube is free to watch online but downloading is against their Terms of Service.
- Ignoring license differences: Not all Creative Commons licenses are the same. CC BY-ND doesn't allow modifications. CC BY-NC prohibits commercial use. Read the specific license.
- Skipping attribution: Many open-licensed works require attribution. Failing to provide it is a license violation. Use the TASL framework (Title, Author, Source, License).
- Redistributing downloaded content: Downloading for personal use does not give you the right to share files with others. Each person should obtain content through legitimate channels.
- Using unofficial tools on restricted platforms: Third-party downloaders for Netflix, Spotify, or YouTube Music almost certainly violate terms of service and may violate copyright law through circumvention of technical protection measures.
- Not checking jurisdiction-specific laws: Fair use in the US is broader than fair dealing in the UK. What's legal in Germany may not be legal in Japan. Know your local copyright law.
- Ignoring platform download features: Many platforms offer legitimate offline access (Spotify Premium, YouTube Premium, Netflix downloads). These are the authorized channels — use them first.
- Assuming podcasts are always okay: While most podcasts explicitly allow downloading via RSS, some podcast content (like audiobooks or music podcasts) may have additional restrictions. Check the specific feed terms.
- Not documenting licenses: When you download legally licensed content, keep records of the license terms and source. Years later, you won't remember where something came from or what you're allowed to do with it.
