diff --git a/.env.example b/.env.example
index 726d178..1ecf6dd 100644
--- a/.env.example
+++ b/.env.example
@@ -58,6 +58,27 @@ MEDIA_URL_TTL_SECONDS=3600
 JOB_HEARTBEAT_SECONDS=30
 JOB_STALE_MINUTES=40
 
+# ─── Import from URL ─────────────────────────────────────────────────────────
+#
+# Pasting a YouTube (or Rumble, Odysee, Vimeo, …) link downloads it with yt-dlp. See
+# docs/url-import.md, including what to do when imports start failing — YouTube
+# changes under yt-dlp every few weeks, and the fix is to bump its pin and rebuild.
+
+# Tallest video to fetch. 1080p is the highest YouTube offers as H.264, which plays in
+# every browser; above it you get VP9/AV1, which Safari may refuse.
+URL_IMPORT_MAX_HEIGHT=1080
+
+# Most videos one playlist or channel link may queue.
+URL_IMPORT_MAX_PLAYLIST_ITEMS=200
+
+# Optional. A Netscape cookies.txt *inside the container*, for YouTube's "confirm you're
+# not a bot" wall (common on VPS/datacenter IPs) and age-restricted videos. Mount it
+# read-only, e.g. in docker-compose.override.yml:
+#   services: { backend: { volumes: ["./secrets/cookies.txt:/app/secrets/cookies.txt:ro"] } }
+# and set: URL_IMPORT_COOKIES_FILE=/app/secrets/cookies.txt
+# Treat that file like a password — it is a signed-in session for the account it came from.
+URL_IMPORT_COOKIES_FILE=
+
 # ─── Development only ────────────────────────────────────────────────────────
 
 # "development" enables DEV_AUTH_USER below. Anything else, and it is ignored.
diff --git a/README.md b/README.md
index c470888..cf58cf2 100644
--- a/README.md
+++ b/README.md
@@ -36,6 +36,10 @@ user row. The changes that makes possible are specified in
 
 - **Ingest with no friction** — drop files in with a name and nothing else. Everything
   beyond that is optional and can be filled in later, by hand or by AI.
+- **Import from a link** — paste a YouTube (or Rumble, Odysee, Vimeo…) URL and it arrives
+  titled, attributed, tagged and split into its chapters, with the site's captions as a
+  transcript when there is no Deepgram key. Playlists too. See
+  [`docs/url-import.md`](docs/url-import.md).
 - **Find the moment** — full-text search over names, descriptions, summaries, tags and
   transcripts, fused with semantic search so half-remembered wording still lands. Hits
   in audio and video come back with a timestamp you can jump straight to.
diff --git a/backend/app/config.py b/backend/app/config.py
index 897fd06..5a713b8 100644
--- a/backend/app/config.py
+++ b/backend/app/config.py
@@ -70,6 +70,19 @@ class Settings(BaseSettings):
     # long upload, both of which contend with serving the API from the same container.
     enrichment_concurrency: int = 1
 
+    # ─── import from URL ─────────────────────────────────────────────────────
+    # The tallest video an import will fetch. 1080p is where YouTube stops offering
+    # H.264, which is the codec every browser (Safari included) plays without a
+    # re-encode — and a ninety-minute interview is ~1-2 GB here against 4-8 GB at 4K.
+    url_import_max_height: int = 1080
+    # A channel's "videos" tab is a playlist too, and can hold thousands. One paste
+    # should not be able to queue a week of downloads.
+    url_import_max_playlist_items: int = 200
+    # A Netscape-format cookies.txt, as a path inside the container. Empty by default.
+    # For YouTube's "confirm you're not a bot" wall on datacenter IPs, and for
+    # age-restricted or members-only videos; mount the file read-only and point here.
+    url_import_cookies_file: str = ""
+
     # ─── development ─────────────────────────────────────────────────────────
     # Bypasses token verification and acts as this user id. Refused unless
     # `environment` is "development", so it cannot be switched on in production by
diff --git a/backend/app/enrichment/import_url.py b/backend/app/enrichment/import_url.py
new file mode 100644
index 0000000..525f965
--- /dev/null
+++ b/backend/app/enrichment/import_url.py
@@ -0,0 +1,461 @@
+"""The import_url job: a link in, a catalogued asset out.
+
+What the user asked for, and the decisions behind each step, are in docs/url-import.md.
+In order:
+
+1. Read the link. A playlist fans out into one job per video and stops there.
+2. Refuse a live stream, and skip a video that is already in the library.
+3. Download it — with the site's captions too, if there is no Deepgram key to
+   transcribe it with instead.
+4. Catalogue it through the same `ingest_file` path an upload takes, so it is probed,
+   posterised, indexed, and queued for Deepgram exactly as an upload would be.
+5. Write what the site said about it, the thumbnail the site shows, the uploader's tags,
+   one clip per chapter, and the captions as a transcript.
+
+Everything after step 4 is best-effort in the way the rest of ingest is: the video is
+safely in the library by then, and a chapter that will not clip must not take it away.
+
+Runs on a worker thread, so it owns its session through the job's, and reports progress
+through the callback the queue hands it — which is also the cancellation checkpoint.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import tempfile
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Callable, Iterable, Optional
+
+from fastapi import HTTPException
+from sqlmodel import Session, col, select
+
+from app.clock import utcnow
+from app.enrichment.deepgram import Transcript
+from app.enrichment.transcribe import store_transcript
+from app.ingest import captions as caption_parser
+from app.ingest import thumbnails, ytdlp
+from app.ingest.filetypes import SOURCE_URL, TYPE_IMAGE
+from app.ingest.ytdlp import ImportedMetadata, UrlImportError
+from app.jobs.runner import readable_error, set_fields
+from app.models.asset import Asset
+from app.models.job import EnrichmentJob
+from app.services import assets as asset_service
+from app.services import suggestions as suggestion_service
+from app.services import tags as tag_service
+from app.settings_store import load_deepgram_key
+from app.storage import StorageError, build_storage, thumb_key_for
+
+logger = logging.getLogger(__name__)
+
+Progress = Callable[[str, int, str], None]
+
+# A playlist entry can itself be a playlist — a channel URL resolves to its tabs, and
+# each tab to its videos. Two levels covers that; anything deeper is a structure nobody
+# meant to import wholesale by pasting one link.
+MAX_PLAYLIST_DEPTH = 2
+
+# A chapter shorter than this is a table-of-contents artefact (a zero-length "Intro"
+# marker, a one-second sponsor stub) rather than something anybody will want to play.
+MIN_CHAPTER_SECONDS = 1.0
+
+
+@dataclass(frozen=True)
+class ImportRequest:
+    """What one import job was asked to do. Carried in `EnrichmentJob.payload`."""
+
+    url: str
+    audio_only: bool = False
+    apply_tags: bool = True
+    chapters_as_clips: bool = True
+    # How many playlists deep this job was queued from. Not user input.
+    depth: int = 0
+
+    def encode(self) -> str:
+        return json.dumps(asdict(self), sort_keys=True)
+
+    @classmethod
+    def decode(cls, payload: Optional[str]) -> "ImportRequest":
+        try:
+            data = json.loads(payload or "{}")
+        except ValueError:
+            data = {}
+        if not isinstance(data, dict) or not isinstance(data.get("url"), str):
+            raise UrlImportError("This import job has no link to fetch")
+        return cls(
+            url=data["url"],
+            audio_only=bool(data.get("audio_only", False)),
+            apply_tags=bool(data.get("apply_tags", True)),
+            chapters_as_clips=bool(data.get("chapters_as_clips", True)),
+            depth=int(data.get("depth") or 0),
+        )
+
+
+@dataclass
+class ImportResult:
+    detail: str
+    created_asset_id: Optional[str] = None
+    # Set only when captions became the transcript, so the worker can chain the embed
+    # job the way it does after a Deepgram run — otherwise the transcript is keyword-
+    # searchable and invisible to semantic search.
+    captioned_asset: Optional[Asset] = None
+
+
+def run(session: Session, job: EnrichmentJob, progress: Progress) -> ImportResult:
+    request = ImportRequest.decode(job.payload)
+
+    try:
+        # Again, although the router already did: a playlist's children arrive here with
+        # URLs the site chose, not the user, and they get the same check.
+        url = ytdlp.normalise_url(request.url)
+    except HTTPException as exc:
+        raise UrlImportError(readable_error(exc)) from exc
+
+    with tempfile.TemporaryDirectory(prefix="gam-import-") as workdir:
+        work = Path(workdir)
+
+        progress("Reading the link", 2, "")
+        info = ytdlp.probe_url(url, work)
+
+        if ytdlp.is_playlist(info):
+            return _fan_out(session, job, request, info)
+
+        ytdlp.refuse_if_live(info)
+        meta = ytdlp.metadata_from_info(info)
+
+        existing = _already_imported(session, job.user_id, [meta.source_url or url])
+        if existing:
+            return ImportResult(
+                detail="Already in your library", created_asset_id=existing[meta.source_url or url]
+            )
+
+        set_fields(session, job, asset_name=meta.title)
+
+        # The user's rule: Deepgram when there is a key (the upload chain queues it on
+        # its own), the site's captions when there is not. Asked once, here, so the
+        # download knows whether to fetch them at all. A stored key that will not
+        # decrypt counts as no key — the upload chain treats it the same way, so
+        # captions are the only transcript this video would otherwise get.
+        try:
+            want_captions = not load_deepgram_key(session, job.user_id)
+        except Exception:  # noqa: BLE001 - a bad setting must not cost the import
+            logger.warning("Could not read the Deepgram key for %s", job.user_id, exc_info=True)
+            want_captions = True
+
+        downloaded = ytdlp.download(
+            url,
+            info,
+            work,
+            audio_only=request.audio_only,
+            want_captions=want_captions,
+            progress=progress,
+        )
+
+        progress("Saving", 90, "")
+        storage = build_storage()
+        try:
+            asset = asset_service.ingest_file(
+                session,
+                storage,
+                user_id=job.user_id,
+                source_path=downloaded.media,
+                filename=_filename_for(meta.title, downloaded.media),
+                name=meta.title,
+                source=SOURCE_URL,
+            )
+        except asset_service.UnsupportedFile as exc:
+            raise UrlImportError(
+                f"The site delivered a {downloaded.media.suffix or 'nameless'} file, "
+                "which the library does not accept"
+            ) from exc
+
+        progress("Recording where it came from", 94, "")
+        _apply_metadata(session, asset, meta)
+        _apply_thumbnail(session, storage, asset, downloaded.thumbnail)
+        tag_note = _apply_tags(session, asset, meta, apply=request.apply_tags)
+        clip_count = _chapters_to_clips(session, asset, meta) if request.chapters_as_clips else 0
+
+        captioned = None
+        if downloaded.captions is not None:
+            progress("Reading captions", 97, "")
+            if _store_captions(session, asset, meta, downloaded):
+                captioned = asset
+
+    detail = "Imported"
+    extras = [
+        note
+        for note in (
+            tag_note,
+            f"{clip_count} chapter clip{'' if clip_count == 1 else 's'}" if clip_count else "",
+            "captions as transcript" if captioned else "",
+        )
+        if note
+    ]
+    if extras:
+        detail += " · " + ", ".join(extras)
+
+    return ImportResult(detail=detail, created_asset_id=asset.id, captioned_asset=captioned)
+
+
+# ─── playlists ───────────────────────────────────────────────────────────────
+
+
+def _fan_out(
+    session: Session, job: EnrichmentJob, request: ImportRequest, info: dict
+) -> ImportResult:
+    """Queue one import per playlist entry, and finish.
+
+    One job per video rather than one job looping over them, for the reasons
+    `bulk.py` gives in the other direction and that point this way here: each download
+    is long, independently fallible, and independently cancellable, and a failure on
+    video 30 of 50 should cost video 30, not videos 31 to 50. Each child gets its own row
+    in the activity feed, and its own asset.
+
+    Entries already in the library are skipped before queueing, so pasting the same
+    playlist next month fetches only what has been added since.
+    """
+    # Imported lazily: `app.jobs.enrichment` imports this module to dispatch to it.
+    from app.jobs import enrichment as enrichment_jobs
+    from app.models.job import KIND_IMPORT_URL
+
+    if request.depth >= MAX_PLAYLIST_DEPTH:
+        raise UrlImportError(
+            "That playlist is nested too deeply to import in one go. "
+            "Paste one of the playlists inside it instead."
+        )
+
+    title = str(info.get("title") or "").strip()
+    if title:
+        set_fields(session, job, asset_name=title[:255])
+
+    entries = ytdlp.playlist_entries(info)
+    if not entries:
+        raise UrlImportError("That playlist has nothing in it that can be imported")
+
+    existing = _already_imported(session, job.user_id, [url for url, _ in entries])
+
+    queued = skipped = 0
+    for url, entry_title in entries:
+        if url in existing:
+            skipped += 1
+            continue
+        child = ImportRequest(
+            url=url,
+            audio_only=request.audio_only,
+            apply_tags=request.apply_tags,
+            chapters_as_clips=request.chapters_as_clips,
+            depth=request.depth + 1,
+        )
+        enrichment_jobs.submit_library(
+            session,
+            job.user_id,
+            KIND_IMPORT_URL,
+            payload=child.encode(),
+            asset_name=(entry_title or url)[:255],
+        )
+        queued += 1
+
+    if queued:
+        detail = f"Queued {queued} import{'' if queued == 1 else 's'}"
+        if skipped:
+            detail += f", {skipped} already in your library"
+    else:
+        detail = f"All {skipped} already in your library"
+
+    total = info.get("playlist_count")
+    if isinstance(total, int) and total > len(entries):
+        detail += f" (the first {len(entries)} of {total})"
+    return ImportResult(detail=detail)
+
+
+def _already_imported(session: Session, user_id: str, urls: Iterable[str]) -> dict[str, str]:
+    """{source_url: asset id} for whichever of these this user already has.
+
+    Matched on the asset's own `source_url` — which a clip leaves blank and inherits —
+    so it finds the original, never one of its clips.
+    """
+    wanted = {u for u in urls if u}
+    if not wanted:
+        return {}
+    rows = session.exec(
+        select(Asset.source_url, Asset.id)
+        .where(Asset.user_id == user_id, col(Asset.source_url).in_(wanted))
+        .order_by(col(Asset.upload_date))
+    ).all()
+    found: dict[str, str] = {}
+    for source_url, asset_id in rows:
+        found.setdefault(source_url, asset_id)
+    return found
+
+
+# ─── after the file is in ────────────────────────────────────────────────────
+
+
+def _filename_for(title: str, media: Path) -> str:
+    """A display filename: the title, with the downloaded file's real extension.
+
+    The extension decides the asset type, so it comes from what yt-dlp actually wrote.
+    Slashes are replaced rather than left to `sanitize_original_name`, which would take
+    only the part after the last one — "AC/DC live" would be stored as "DC live".
+    """
+    stem = title.replace("/", "-").replace("\\", "-").strip() or "download"
+    return f"{stem[:200]}{media.suffix.lower()}"
+
+
+def _apply_metadata(session: Session, asset: Asset, meta: ImportedMetadata) -> None:
+    """What the site says about the video, stamped `embedded`.
+
+    `embedded` rather than `human` or `ai`: it is a statement of fact from the source
+    that nobody here has checked — the same standing as an EXIF Artist, which is what
+    that stamp means. The row is minutes old, so nothing a person wrote can be
+    overwritten; what can be is whatever the harvester read out of the file's own
+    container tags, and the site is the better authority on its own video.
+
+    `retrieved_at` is the one attribution field only an import can know, and the reason
+    M10 left it without an automatic writer until now.
+    """
+    changes: dict = dict(meta.attribution)
+    changes["retrieved_at"] = utcnow()
+    if meta.description:
+        changes["description"] = meta.description
+    try:
+        asset_service.apply_embedded_metadata(session, asset, changes)
+    except Exception:  # noqa: BLE001 - the video is in; losing its metadata must not undo that
+        logger.warning("Could not store imported metadata for %s", asset.id, exc_info=True)
+
+
+def _apply_thumbnail(session: Session, storage, asset: Asset, source: Optional[Path]) -> None:
+    """Use the site's own thumbnail instead of a frame GAM picked.
+
+    The one the uploader chose is the picture people remember the video by, which is
+    what a library grid is for. It matters most for audio-only imports, which otherwise
+    have no picture at all. Written over the generated poster at the same key, so
+    nothing else — the clips made next copy this `thumb_key` — needs to know.
+    """
+    if source is None or not asset.storage_key:
+        return
+    preview = thumbnails.generate(source, TYPE_IMAGE, source.name)
+    if not preview:
+        return
+    try:
+        stored = storage.write_bytes(thumb_key_for(asset.storage_key), preview)
+    except (StorageError, OSError):
+        logger.warning("Could not store the site thumbnail for %s", asset.id, exc_info=True)
+        return
+    asset.thumb_key = stored.key
+    session.add(asset)
+    session.commit()
+    session.refresh(asset)
+
+
+def _apply_tags(session: Session, asset: Asset, meta: ImportedMetadata, *, apply: bool) -> str:
+    """The uploader's tags — applied, or offered as suggestions.
+
+    Applied by default, which is the user's decision and differs from autotag's rule that
+    nothing is ever applied silently (FR 9.1.4). That rule exists because a model's tags
+    are a guess; these are what the uploader chose to call their own video, closer to
+    embedded metadata than to inference. Unticking "Apply the uploader's tags" on the
+    import form routes them through the suggestion queue instead, for channels that pad
+    their tags for search.
+    """
+    if not meta.tags:
+        return ""
+    try:
+        if not apply:
+            count = suggestion_service.propose(
+                session,
+                asset,
+                tags=meta.tags,
+                title=None,
+                model=f"{meta.extractor or 'site'} tags",
+            )
+            return f"{count} tag suggestion{'' if count == 1 else 's'}" if count else ""
+
+        attached = 0
+        for name in meta.tags:
+            tag = tag_service.get_or_create(session, asset.user_id, name)
+            if tag is not None and tag_service.attach(session, asset.id, tag.id):
+                attached += 1
+        asset_service.reindex_ids(session, [asset.id])
+        return f"{attached} tag{'' if attached == 1 else 's'}" if attached else ""
+    except Exception:  # noqa: BLE001 - see _apply_metadata
+        logger.warning("Could not apply imported tags to %s", asset.id, exc_info=True)
+        return ""
+
+
+def _chapters_to_clips(session: Session, asset: Asset, meta: ImportedMetadata) -> int:
+    """One non-destructive clip per chapter.
+
+    Clamped to the probed duration: sites round, and a last chapter ending a fraction of
+    a second past the end of the file would otherwise be refused by `create_clip`. A lone
+    chapter covering the whole video is skipped — it would be a clip identical to its
+    parent.
+
+    Named "<chapter> — <video>" because a clip appears in the library grid and in search
+    results on its own, where "Introduction" says nothing.
+    """
+    chapters = meta.chapters
+    if len(chapters) < 2:
+        return 0
+
+    duration = asset.duration_seconds
+    created = 0
+    for chapter in chapters:
+        start = max(0.0, chapter.start)
+        end = chapter.end if chapter.end is not None else duration
+        if end is None:
+            continue
+        if duration:
+            end = min(end, duration)
+        if end - start < MIN_CHAPTER_SECONDS:
+            continue
+        label = chapter.title or f"Part {created + 1}"
+        try:
+            asset_service.create_clip(
+                session,
+                asset,
+                in_point=start,
+                out_point=end,
+                name=f"{label} — {asset.name}"[:255],
+            )
+            created += 1
+        except ValueError as exc:
+            logger.info("Skipped chapter %r of %s: %s", label, asset.id, exc)
+        except Exception:  # noqa: BLE001 - see _apply_metadata
+            logger.warning("Could not clip chapter %r of %s", label, asset.id, exc_info=True)
+    return created
+
+
+def _store_captions(
+    session: Session, asset: Asset, meta: ImportedMetadata, downloaded: ytdlp.Downloaded
+) -> bool:
+    """The site's captions as this asset's transcript. Returns whether any were stored.
+
+    The model name records which kind they were, so the transcript panel — and whoever
+    wonders why a transcript has no speakers — can tell a creator's own subtitles from a
+    machine's.
+    """
+    try:
+        text = downloaded.captions.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        logger.warning("Could not read downloaded captions for %s", asset.id, exc_info=True)
+        return False
+
+    segments = caption_parser.parse_vtt(text)
+    if not segments:
+        return False
+
+    site = meta.extractor or "site"
+    kind = "auto-captions" if downloaded.captions_automatic else "captions"
+    language = downloaded.captions_language.removesuffix("-orig")
+    try:
+        store_transcript(
+            session,
+            asset,
+            Transcript(segments=segments, language=language, model=f"{site}-{kind}"),
+        )
+    except Exception:  # noqa: BLE001 - see _apply_metadata
+        logger.warning("Could not store captions for %s", asset.id, exc_info=True)
+        return False
+    return True
diff --git a/backend/app/enrichment/transcribe.py b/backend/app/enrichment/transcribe.py
index 294521c..73dc951 100644
--- a/backend/app/enrichment/transcribe.py
+++ b/backend/app/enrichment/transcribe.py
@@ -98,6 +98,18 @@ def run(session: Session, asset: Asset, progress: Progress) -> int:
     # not still land a transcript afterwards.
     progress("Storing", 90, f"{len(transcript.segments)} segments")
 
+    return store_transcript(session, asset, transcript)
+
+
+def store_transcript(session: Session, asset: Asset, transcript: deepgram.Transcript) -> int:
+    """Write a transcript, index it, and mark the asset transcribed.
+
+    Split out of `run` because Deepgram is no longer the only source: a URL import with
+    no Deepgram key stores the platform's captions through here (`ingest/captions.py`).
+    One writer means captions get the same edited-segment protection, the same keyword
+    indexing and the same header fields — and a later Deepgram run replaces them exactly
+    the way it would replace an earlier Deepgram transcript.
+    """
     stored = _store_segments(session, asset, transcript)
 
     # Index what was said, so it is findable the moment the job finishes rather than
diff --git a/backend/app/ingest/captions.py b/backend/app/ingest/captions.py
new file mode 100644
index 0000000..b6672d7
--- /dev/null
+++ b/backend/app/ingest/captions.py
@@ -0,0 +1,140 @@
+"""A platform's captions, turned into transcript segments.
+
+The free fallback for URL imports when no Deepgram key is configured (the user's call,
+recorded in docs/url-import.md): a video whose captions are stored as its transcript is
+searchable by what was said the moment it lands, rather than never. Deepgram stays the
+better transcript — diarised, word-timed, punctuated — and a later run replaces these
+rows exactly as it would replace an earlier Deepgram transcript.
+
+Pure: text in, `deepgram.Segment`s out. Reusing that dataclass rather than inventing a
+caption-shaped twin is what lets `transcribe.store_transcript` write both.
+
+VTT only. yt-dlp converts whatever a site serves (SRT, TTML, json3) to VTT before this
+sees it, so one parser covers every extractor.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+from app.enrichment.deepgram import Segment
+
+# `00:01:02.500 --> 00:01:05.000 align:start position:0%` — hours optional, and a comma
+# accepted as well as a dot, since a converter that slipped SRT through would use one.
+_CUE_TIMING = re.compile(
+    r"^\s*((?:\d+:)?\d{1,2}:\d{2}[.,]\d{1,3})\s+-->\s+((?:\d+:)?\d{1,2}:\d{2}[.,]\d{1,3})"
+)
+
+# Inline markup: YouTube's per-word karaoke timestamps (`<00:00:01.200>`), `<c>` spans,
+# voice tags, italics. None of it is speech.
+_TAG = re.compile(r"<[^>]*>")
+
+# A line that is nothing but a sound annotation — `[Music]`, `[Applause]`, `(laughs)`.
+# Kept out because it is not what anybody said: it would match a search for "music" in
+# every video with a sting, and pad a summary with stage directions.
+_SOUND_ONLY = re.compile(r"^[\[(][^\])]*[\])]$")
+
+# A segment is closed at the end of a sentence, at a pause, or when it has run long.
+# Manual captions are punctuated, so the first rule produces sentence-sized rows like
+# Deepgram's utterances. Auto-captions mostly are not, and the other two keep a search
+# snippet from being a two-minute wall of text.
+_SENTENCE_END = re.compile(r"[.?!…][\"')\]]*$")
+MAX_SEGMENT_SECONDS = 20.0
+PAUSE_SECONDS = 2.0
+
+
+@dataclass
+class _Line:
+    text: str
+    start: float
+    end: float
+
+
+def parse_vtt(text: str) -> list[Segment]:
+    """Segments from a WebVTT document, in order. Empty for anything unreadable."""
+    return _merge(_lines(text or ""))
+
+
+def _lines(text: str) -> list[_Line]:
+    """Every distinct spoken line, with the span over which it was on screen.
+
+    The deduplication is the part that matters. YouTube's auto-caption VTT is a rolling
+    two-line display: each cue repeats the line before it and adds the next, and a
+    ten-millisecond cue in between shows the finished line alone. Read naively, every
+    sentence appears two or three times. Comparing against the last line kept drops the
+    repeats and extends that line's end time instead, which is what the viewer saw.
+    """
+    kept: list[_Line] = []
+    start: Optional[float] = None
+    end = 0.0
+
+    for raw in text.splitlines():
+        timing = _CUE_TIMING.match(raw)
+        if timing:
+            start, end = _seconds(timing.group(1)), _seconds(timing.group(2))
+            continue
+        if not raw.strip():
+            # A blank line ends the cue. Whatever comes before the next timing line is
+            # the header, a NOTE or STYLE block, or a cue identifier — numbered cues are
+            # common, and without this "2" and "3" would be read as things people said.
+            # YouTube's whitespace-only filler lines land here too, which is harmless:
+            # nothing follows them inside the same cue.
+            start = None
+            continue
+        if start is None:
+            continue
+        line = _clean(raw)
+        if not line:
+            continue
+        if kept and kept[-1].text == line:
+            kept[-1].end = max(kept[-1].end, end)
+            continue
+        kept.append(_Line(text=line, start=start, end=end))
+
+    return kept
+
+
+def _merge(lines: list[_Line]) -> list[Segment]:
+    segments: list[Segment] = []
+    current: list[_Line] = []
+
+    def close() -> None:
+        if current:
+            segments.append(
+                Segment(
+                    text=" ".join(line.text for line in current),
+                    start=round(current[0].start, 3),
+                    end=round(max(line.end for line in current), 3),
+                )
+            )
+            current.clear()
+
+    for line in lines:
+        if current and line.start - current[-1].end > PAUSE_SECONDS:
+            close()
+        current.append(line)
+        spoken = current[-1].end - current[0].start
+        if _SENTENCE_END.search(line.text) or spoken >= MAX_SEGMENT_SECONDS:
+            close()
+    close()
+
+    return segments
+
+
+def _clean(raw: str) -> str:
+    line = html.unescape(_TAG.sub("", raw)).replace(" ", " ")
+    line = " ".join(line.split())
+    if _SOUND_ONLY.match(line):
+        return ""
+    return line
+
+
+def _seconds(stamp: str) -> float:
+    parts = stamp.replace(",", ".").split(":")
+    total = 0.0
+    for part in parts:
+        total = total * 60 + float(part)
+    return total
diff --git a/backend/app/ingest/ytdlp.py b/backend/app/ingest/ytdlp.py
new file mode 100644
index 0000000..c2bb7e3
--- /dev/null
+++ b/backend/app/ingest/ytdlp.py
@@ -0,0 +1,620 @@
+"""Everything GAM asks of yt-dlp, in one module.
+
+The only file that imports `yt_dlp`. yt-dlp's option names and info-dict keys are a
+large, loosely documented surface that shifts between releases, and keeping every use of
+it here means a release that renames something is one file to fix — and one fake to
+update in the tests, which never touch the network.
+
+Three calls: `probe_url` reads what a link is, `download` fetches it, and
+`metadata_from_info` (pure) maps what the site said onto GAM's fields. The job that
+strings them together is `enrichment/import_url.py`.
+
+Why these particular options is recorded beside each one. The two that matter most:
+
+- **`allowed_extractors` excludes `generic`.** yt-dlp knows ~1,800 sites by name; its
+  generic extractor is the fallback that scrapes *any* page for something playable. That
+  fallback is the part a user-supplied URL could aim at an internal address, and it is
+  also the part most likely to import the wrong thing. Named sites only.
+- **No `ignoreerrors`.** Every failure raises, so a cancel raised from a progress hook
+  unwinds the download instead of being logged and skipped past.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+import time
+import urllib.parse
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+import yt_dlp
+from fastapi import HTTPException, status
+from yt_dlp.utils import DownloadCancelled, DownloadError
+
+from app.config import settings
+from app.ingest.embedded_metadata import normalise_partial_date
+from app.jobs.runner import JobCancelled
+from app.safe_url import require_safe_external_url
+
+logger = logging.getLogger(__name__)
+
+Progress = Callable[[str, int, str], None]
+
+# The same ceilings AssetUpdate puts on a hand-typed value, so an import cannot store
+# something a person editing the field afterwards would be refused.
+MAX_DESCRIPTION = 20_000
+MAX_ATTRIBUTION = 500
+MAX_URL = 2_000
+# The tag API's own limits (schemas_tags.py). A YouTube video can carry up to 500
+# characters of tags, which lands well under fifty in practice.
+MAX_TAG_LENGTH = 80
+MAX_TAGS = 50
+
+# What a download may be left as. Anything else is remuxed to MP4 — a stream copy, not a
+# re-encode — so the library never receives a container it would refuse (`.ts`, `.3gp`)
+# or one browsers play badly (`.flv`). Audio stays audio: without its own entries here, a
+# podcast's `.mp3` would be remuxed into an `.mp4` and catalogued as video.
+_KEEP_CONTAINERS = ("mp4", "m4v", "webm", "mkv", "mov", "m4a", "mp3", "ogg", "opus", "flac", "wav", "aac")
+_REMUX_MAPPING = "/".join(f"{ext}>{ext}" for ext in _KEEP_CONTAINERS) + "/mp4"
+
+
+# An explicit scheme: letters, then a colon *not* followed by a digit. The digit rule is
+# what tells `javascript:…` (a scheme, refused) from `example.com:8443/…` (a host and a
+# port, which gets https:// put in front like any other bare link).
+_SCHEME = re.compile(r"^[a-z][a-z0-9+.\-]*:(?!\d)", re.IGNORECASE)
+
+
+class UrlImportError(Exception):
+    """Something the user can be told about — the job's error message, verbatim."""
+
+
+# ─── the URL ─────────────────────────────────────────────────────────────────
+
+
+def normalise_url(raw: str) -> str:
+    """The URL as it will be fetched, or an HTTPException saying why not.
+
+    Forgiving about the two ways people actually paste links — `youtu.be/…` with no
+    scheme, and the occasional `http://` — and strict about everything else. Every site
+    worth importing from serves https, so upgrading costs nothing and lets
+    `require_safe_external_url` keep its https-only rule rather than growing an exception.
+    """
+    url = (raw or "").strip()
+    if not url:
+        _invalid("Paste a link to import")
+    if not _SCHEME.match(url):
+        url = f"https://{url}"
+
+    parsed = urllib.parse.urlsplit(url)
+    if parsed.scheme.lower() == "http":
+        url = urllib.parse.urlunsplit(parsed._replace(scheme="https"))
+    elif parsed.scheme.lower() != "https":
+        _invalid("Only web links (https://…) can be imported")
+    try:
+        parsed.port
+    except ValueError:
+        _invalid("That link has an invalid port")
+
+    if len(url) > MAX_URL:
+        _invalid("That link is too long")
+
+    # Checked here as well as by `allowed_extractors`: that excludes the extractor that
+    # fetches arbitrary pages, and this refuses a named-site URL whose host resolves
+    # inward. Neither alone is the whole of it.
+    require_safe_external_url(url)
+    return url
+
+
+def _invalid(message: str) -> None:
+    raise HTTPException(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        detail={"code": "invalid_url", "message": message},
+    )
+
+
+# ─── reading a link ──────────────────────────────────────────────────────────
+
+
+def probe_url(url: str, workdir: Path) -> dict:
+    """What `url` is — one video, or a playlist of them — without downloading.
+
+    Playlists come back flat (`extract_flat="in_playlist"`): each entry is a URL and a
+    title, not a fully resolved video. Resolving two hundred entries here would take
+    minutes and spend two hundred page loads on videos that are about to be queued as
+    their own jobs, which resolve them anyway.
+    """
+    options = {
+        **_base_options(workdir),
+        "extract_flat": "in_playlist",
+        "playlist_items": f"1:{max(1, settings.url_import_max_playlist_items)}",
+    }
+    with yt_dlp.YoutubeDL(options) as ydl:
+        try:
+            info = ydl.extract_info(url, download=False)
+        except DownloadError as exc:
+            raise UrlImportError(readable_error(exc)) from exc
+    if not info:
+        raise UrlImportError("Nothing importable was found at that link")
+    return info
+
+
+def is_playlist(info: dict) -> bool:
+    return info.get("_type") in ("playlist", "multi_video")
+
+
+def playlist_entries(info: dict) -> list[tuple[str, str]]:
+    """(url, title) for each playlist entry that has an absolute URL.
+
+    Entries without one are skipped rather than guessed at: some extractors hand back a
+    bare id there, and turning that into a URL is the extractor's knowledge, not ours.
+    """
+    found = []
+    for entry in info.get("entries") or []:
+        if not isinstance(entry, dict):
+            continue
+        url = entry.get("url") or entry.get("webpage_url") or ""
+        if "://" not in url:
+            continue
+        found.append((url, str(entry.get("title") or "").strip()))
+    return found
+
+
+def refuse_if_live(info: dict) -> None:
+    """A live stream would download until it ended — which may be never."""
+    live_status = info.get("live_status")
+    if info.get("is_live") or live_status == "is_live":
+        raise UrlImportError("That is a live stream. Import it once it has finished.")
+    if live_status == "is_upcoming":
+        raise UrlImportError("That stream has not started yet.")
+    if live_status == "post_live":
+        raise UrlImportError(
+            "That stream has only just ended and is still being processed. "
+            "Try again in an hour or two."
+        )
+
+
+# ─── downloading ─────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class Downloaded:
+    media: Path
+    thumbnail: Optional[Path] = None
+    captions: Optional[Path] = None
+    captions_language: str = ""
+    # Machine captions rather than ones somebody wrote. Recorded on the transcript as
+    # its model, so it is visible which kind a search is matching against.
+    captions_automatic: bool = False
+
+
+@dataclass(frozen=True)
+class CaptionChoice:
+    language: str
+    automatic: bool
+
+
+def download(
+    url: str,
+    info: dict,
+    workdir: Path,
+    *,
+    audio_only: bool,
+    want_captions: bool,
+    progress: Progress,
+) -> Downloaded:
+    """Fetch the media, its thumbnail and — when asked — its captions into `workdir`.
+
+    `info` is the probe's answer, read here only to choose a caption track. The download
+    itself extracts the page again rather than re-processing that dict. Re-processing
+    would save a few seconds, and it is what `--load-info-json` does — but a resolved
+    info dict can hold format URLs that have already expired and fragment lists that do
+    not survive a round trip, and this path cannot be exercised against the real sites
+    in CI. A fresh `extract_info(download=True)` is the call every yt-dlp user makes,
+    which makes it the one least likely to break quietly.
+    """
+    captions = choose_captions(info) if want_captions else None
+
+    options: dict[str, Any] = {
+        **_base_options(workdir),
+        "paths": {"home": str(workdir), "temp": str(workdir)},
+        # Fixed names: the title is recorded as metadata, and a filename built from it
+        # is a filename built from text the site controls.
+        "outtmpl": {
+            "default": "media.%(ext)s",
+            "thumbnail": "thumb.%(ext)s",
+            "subtitle": "captions.%(ext)s",
+        },
+        # No conversion: Pillow reads the jpg/webp/png sites serve, and
+        # `thumbnails.generate` re-encodes to the library's JPEG anyway.
+        "writethumbnail": True,
+        "progress_hooks": [_progress_hook(progress)],
+        "postprocessor_hooks": [_postprocessor_hook(progress)],
+    }
+
+    if audio_only:
+        options["format"] = "ba[ext=m4a]/ba/b"
+        options["postprocessors"] = [{"key": "FFmpegExtractAudio", "preferredcodec": "m4a"}]
+    else:
+        # `format_sort` rather than a filter: the tallest stream at or under the cap wins,
+        # H.264 over VP9/AV1 at the same height (Safari will not play the latter from an
+        # MP4), and a video with nothing under the cap still downloads its smallest
+        # stream instead of failing outright.
+        options["format"] = "bv*+ba/b"
+        options["format_sort"] = [
+            f"res:{max(144, settings.url_import_max_height)}",
+            "vcodec:h264",
+            "acodec:m4a",
+        ]
+        options["merge_output_format"] = "mp4"
+        options["postprocessors"] = [
+            {"key": "FFmpegVideoRemuxer", "preferedformat": _REMUX_MAPPING},
+        ]
+
+    if captions:
+        options["subtitleslangs"] = [captions.language]
+        options["subtitlesformat"] = "vtt/best"
+        if captions.automatic:
+            options["writeautomaticsub"] = True
+        else:
+            options["writesubtitles"] = True
+        options["postprocessors"].append(
+            {"key": "FFmpegSubtitlesConvertor", "format": "vtt", "when": "before_dl"}
+        )
+
+    with yt_dlp.YoutubeDL(options) as ydl:
+        try:
+            result = ydl.extract_info(url, download=True)
+        except DownloadCancelled as exc:
+            raise JobCancelled(str(exc)) from exc
+        except DownloadError as exc:
+            raise UrlImportError(readable_error(exc)) from exc
+
+    media = _media_path(result, workdir)
+    return Downloaded(
+        media=media,
+        thumbnail=_first(workdir, ("thumb.jpg", "thumb.jpeg", "thumb.webp", "thumb.png")),
+        captions=_first_glob(workdir, "captions*.vtt") if captions else None,
+        captions_language=captions.language if captions else "",
+        captions_automatic=bool(captions and captions.automatic),
+    )
+
+
+def choose_captions(info: dict) -> Optional[CaptionChoice]:
+    """The one caption track worth storing as a transcript, if there is one.
+
+    Written by a person beats machine-made, and the video's own language beats a
+    translation — YouTube offers auto-translated tracks into a hundred languages, all of
+    them worse than the original. YouTube marks its original-language speech recognition
+    track `<lang>-orig`; the plain `<lang>` beside it may be a translation.
+    """
+    manual = {k: v for k, v in (info.get("subtitles") or {}).items() if k != "live_chat" and v}
+    automatic = {k: v for k, v in (info.get("automatic_captions") or {}).items() if v}
+    spoken = (info.get("language") or "").strip()
+
+    if spoken:
+        for key in (spoken, *sorted(k for k in manual if k.split("-")[0] == spoken)):
+            if key in manual:
+                return CaptionChoice(key, automatic=False)
+        for key in (f"{spoken}-orig", spoken):
+            if key in automatic:
+                return CaptionChoice(key, automatic=True)
+
+    # The language is not stated. One hand-written track is almost certainly the
+    # original; several are a guess, and English is the likeliest.
+    if len(manual) == 1:
+        return CaptionChoice(next(iter(manual)), automatic=False)
+    for key in sorted(manual):
+        if key.split("-")[0] == "en":
+            return CaptionChoice(key, automatic=False)
+    for key in sorted(automatic):
+        if key.endswith("-orig"):
+            return CaptionChoice(key, automatic=True)
+    return None
+
+
+def _media_path(result: Optional[dict], workdir: Path) -> Path:
+    """Where the finished file ended up, after merging and any remux or extraction.
+
+    `requested_downloads` carries the final path once postprocessors have run. The glob
+    is the fallback for an extractor that does not fill it in, and excludes the sidecar
+    and scratch files that share the directory.
+    """
+    for entry in (result or {}).get("requested_downloads") or []:
+        path = entry.get("filepath")
+        if path and Path(path).is_file():
+            return Path(path)
+    for candidate in sorted(workdir.glob("media.*")):
+        if candidate.suffix.lower() not in (".part", ".ytdl", ".vtt", ".json") and candidate.is_file():
+            return candidate
+    raise UrlImportError("The download finished but produced no file")
+
+
+def _first(workdir: Path, names: tuple[str, ...]) -> Optional[Path]:
+    for name in names:
+        path = workdir / name
+        if path.is_file():
+            return path
+    return None
+
+
+def _first_glob(workdir: Path, pattern: str) -> Optional[Path]:
+    return next((p for p in sorted(workdir.glob(pattern)) if p.is_file()), None)
+
+
+def _progress_hook(progress: Progress) -> Callable[[dict], None]:
+    """Report download progress, at most about once a second.
+
+    yt-dlp calls this on every chunk — hundreds of times a second on a fast line — and
+    each report is a database write. It is also the cancellation checkpoint: the job's
+    reporter raises `JobCancelled`, which is converted to `DownloadCancelled`, the
+    exception yt-dlp's own code is written to let through untouched.
+    """
+    last = [0.0]
+
+    def hook(state: dict) -> None:
+        if state.get("status") != "downloading":
+            return
+        now = time.monotonic()
+        if now - last[0] < 1.0:
+            return
+        last[0] = now
+
+        done = state.get("downloaded_bytes") or 0
+        total = state.get("total_bytes") or state.get("total_bytes_estimate") or 0
+        fraction = min(1.0, done / total) if total else 0.0
+        # A `bv*+ba` download is two files one after the other; saying which keeps the
+        # bar dropping back to zero from reading as a restart.
+        stream = (state.get("info_dict") or {}).get("vcodec")
+        stage = "Downloading audio" if stream in (None, "none") else "Downloading video"
+        detail = f"{done / 1_048_576:.0f} of {total / 1_048_576:.0f} MB" if total else ""
+        try:
+            progress(stage, 5 + int(fraction * 80), detail)
+        except JobCancelled as exc:
+            raise DownloadCancelled() from exc
+
+    return hook
+
+
+def _postprocessor_hook(progress: Progress) -> Callable[[dict], None]:
+    """Say so while ffmpeg merges or converts — minutes, for a long video."""
+
+    def hook(state: dict) -> None:
+        if state.get("status") != "started":
+            return
+        name = state.get("postprocessor") or ""
+        stage = "Merging audio and video" if name == "Merger" else "Converting"
+        try:
+            progress(stage, 88, "")
+        except JobCancelled as exc:
+            raise DownloadCancelled() from exc
+
+    return hook
+
+
+# ─── options and errors ──────────────────────────────────────────────────────
+
+
+class _Logger:
+    """Route yt-dlp's chatter into logging instead of the server's stdout.
+
+    Errors are only logged: every one of them is also raised as a `DownloadError`, which
+    is where the user hears about it.
+    """
+
+    def debug(self, msg: str) -> None:
+        pass
+
+    def info(self, msg: str) -> None:
+        pass
+
+    def warning(self, msg: str) -> None:
+        logger.info("yt-dlp: %s", msg)
+
+    def error(self, msg: str) -> None:
+        logger.info("yt-dlp: %s", msg)
+
+
+def _base_options(workdir: Path) -> dict[str, Any]:
+    options: dict[str, Any] = {
+        "quiet": True,
+        "no_warnings": True,
+        "noprogress": True,
+        "logger": _Logger(),
+        "allowed_extractors": ["default", "-generic"],
+        # A watch URL carrying `&list=` imports the video that was open, not the
+        # playlist it happened to be in. A bare playlist URL is still a playlist.
+        "noplaylist": True,
+        "ignoreerrors": False,
+        "socket_timeout": 30,
+        "retries": 10,
+        "fragment_retries": 10,
+    }
+
+    cookies = settings.url_import_cookies_file.strip()
+    if cookies:
+        source = Path(cookies)
+        if not source.is_file():
+            raise UrlImportError(
+                f"URL_IMPORT_COOKIES_FILE is set to {cookies}, but there is no file there"
+            )
+        # A copy, because yt-dlp writes the jar back out when it closes — which fails on
+        # the read-only mount the docs recommend, and would otherwise rewrite the user's
+        # own file with whatever the site set during this one import.
+        copy = workdir / "cookies.txt"
+        shutil.copyfile(source, copy)
+        options["cookiefile"] = str(copy)
+
+    return options
+
+
+_ERROR_PREFIX = re.compile(r"^(?:ERROR:\s*)?(?:\[[^\]]+\]\s*)?(?:[\w-]+:\s+)?")
+
+# Messages worth replacing with what to actually do about them.
+_NEEDS_COOKIES = ("confirm you're not a bot", "confirm you’re not a bot", "confirm your age", "sign in to confirm")
+_NEEDS_UPDATE = (
+    "requested format is not available",
+    "signature",
+    "nsig",
+    "n challenge",
+    "javascript runtime",
+    "js runtime",
+    "player response",
+)
+
+
+def readable_error(exc: Exception) -> str:
+    """A yt-dlp failure as something a person can act on.
+
+    yt-dlp's messages are written for a terminal user — `ERROR: [youtube] abc123: …` —
+    and several of them tell that user to pass a command-line flag this app has no way
+    to accept. Three cases get rewritten into what to do here instead; the rest keep
+    yt-dlp's own words, minus the prefix.
+    """
+    message = str(getattr(exc, "msg", None) or exc).strip()
+    lowered = message.lower()
+
+    if "no suitable extractor" in lowered or "unsupported url" in lowered:
+        return "That site is not one yt-dlp knows how to import from."
+    if any(phrase in lowered for phrase in _NEEDS_COOKIES):
+        return (
+            "The site wants this server to sign in first (YouTube does this to many "
+            "datacenter IPs, and for age-restricted videos). Export your browser's "
+            "cookies for the site to a file and set URL_IMPORT_COOKIES_FILE — see "
+            "docs/url-import.md."
+        )
+
+    first_line = message.splitlines()[0] if message else ""
+    cleaned = _ERROR_PREFIX.sub("", first_line, count=1).strip() or "The import failed"
+    if any(phrase in lowered for phrase in _NEEDS_UPDATE):
+        cleaned += (
+            " — this usually means the site changed and yt-dlp needs updating: bump its "
+            "version in backend/requirements.txt and rebuild."
+        )
+    return cleaned
+
+
+# ─── mapping what the site said ──────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class Chapter:
+    start: float
+    end: Optional[float]
+    title: str
+
+
+@dataclass(frozen=True)
+class ImportedMetadata:
+    title: str
+    description: Optional[str]
+    # Only fields the site actually supplied. See `metadata_from_info` for the mapping.
+    attribution: dict[str, Any]
+    tags: list[str] = field(default_factory=list)
+    chapters: list[Chapter] = field(default_factory=list)
+    # yt-dlp's name for the site ("youtube", "rumble"), for labelling where tags and
+    # captions came from.
+    extractor: str = ""
+
+    @property
+    def source_url(self) -> Optional[str]:
+        return self.attribution.get("source_url")
+
+
+def metadata_from_info(info: dict) -> ImportedMetadata:
+    """Map a yt-dlp info dict onto GAM's fields. Pure.
+
+    The attribution mapping follows M10's rule that a blank beats a guess:
+
+    - `publisher` is the channel. On every video site that is the outlet — the BBC's
+      channel, a podcast's feed — which is what the field means.
+    - `creator` is filled only when the site names one (`creators`, `artists`: music
+      and some podcasts). It is *not* copied from the channel. On a news or interview
+      channel the channel is rarely the person speaking, and a creator field that
+      confidently says "BBC News" is the fabricated citation M10 exists to prevent. The
+      attribute job can propose the speaker from the transcript, with evidence.
+    - `source_title` is the series or album when there is one, otherwise the video's
+      own title. `name` gets the title too, but `name` is the user's to rename; the
+      citation should keep what the work was actually published as.
+    - `license` only when the site states one. YouTube reports Creative Commons and
+      says nothing for its standard licence, and nothing is invented for it.
+    """
+    title = _text(info.get("title") or info.get("fulltitle")) or _text(info.get("id")) or "Untitled"
+
+    description = _text(info.get("description"))
+    if description:
+        description = description[:MAX_DESCRIPTION]
+
+    attribution: dict[str, Any] = {}
+
+    def put(name: str, value: Any) -> None:
+        cleaned = _text(value)
+        if cleaned:
+            attribution[name] = cleaned[: MAX_URL if name == "source_url" else MAX_ATTRIBUTION]
+
+    put("source_url", info.get("webpage_url") or info.get("original_url"))
+    put("publisher", info.get("channel") or info.get("uploader"))
+    put("creator", _joined(info.get("creators") or info.get("artists")) or info.get("creator") or info.get("artist"))
+    put("source_title", info.get("series") or info.get("album") or title)
+    put("license", info.get("license"))
+
+    published = normalise_partial_date(info.get("release_date") or info.get("upload_date"))
+    if not published and info.get("release_year"):
+        published = normalise_partial_date(str(info["release_year"]))
+    if published:
+        attribution["published_date"] = published
+
+    return ImportedMetadata(
+        title=title[:255],
+        description=description,
+        attribution=attribution,
+        tags=_tags(info.get("tags")),
+        chapters=_chapters(info.get("chapters")),
+        extractor=_text(info.get("extractor_key") or info.get("extractor")).lower(),
+    )
+
+
+def _text(value: Any) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def _joined(values: Any) -> str:
+    if not isinstance(values, (list, tuple)):
+        return ""
+    return ", ".join(v.strip() for v in values if isinstance(v, str) and v.strip())
+
+
+def _tags(raw: Any) -> list[str]:
+    """Uploader tags, cleaned: whitespace collapsed, case-insensitive duplicates and
+    over-long ones dropped, capped at what one tag request may carry."""
+    if not isinstance(raw, (list, tuple)):
+        return []
+    seen: set[str] = set()
+    tags: list[str] = []
+    for value in raw:
+        name = " ".join(value.split()) if isinstance(value, str) else ""
+        if not name or len(name) > MAX_TAG_LENGTH or name.lower() in seen:
+            continue
+        seen.add(name.lower())
+        tags.append(name)
+        if len(tags) >= MAX_TAGS:
+            break
+    return tags
+
+
+def _chapters(raw: Any) -> list[Chapter]:
+    if not isinstance(raw, (list, tuple)):
+        return []
+    chapters = []
+    for entry in raw:
+        if not isinstance(entry, dict):
+            continue
+        try:
+            start = float(entry.get("start_time") or 0.0)
+            end = float(entry["end_time"]) if entry.get("end_time") is not None else None
+        except (TypeError, ValueError):
+            continue
+        chapters.append(Chapter(start=start, end=end, title=_text(entry.get("title"))))
+    return chapters
diff --git a/backend/app/jobs/enrichment.py b/backend/app/jobs/enrichment.py
index 9a18ae9..29384c5 100644
--- a/backend/app/jobs/enrichment.py
+++ b/backend/app/jobs/enrichment.py
@@ -29,11 +29,13 @@
 from app.enrichment.extract_text import TextExtractionError
 from app.enrichment.extract_text import run as run_extract_text
 from app.enrichment.generate_all import run as run_generate_all
+from app.enrichment.import_url import run as run_import_url
 from app.enrichment.source import NoSourceMaterial
 from app.enrichment.subvideo import SubvideoExtractionError
 from app.enrichment.summarize import run as run_summarize
 from app.enrichment.transcribe import TranscriptionError
 from app.enrichment.transcribe import run as run_transcribe
+from app.ingest.ytdlp import UrlImportError
 from app.providers.base import ProviderError
 from app.jobs.runner import (
     ACTIVE_STATUSES,
@@ -55,6 +57,7 @@
     KIND_EXTRACT_SUBVIDEO,
     KIND_EXTRACT_TEXT,
     KIND_GENERATE_ALL,
+    KIND_IMPORT_URL,
     KIND_SUMMARIZE,
     KIND_TRANSCRIBE,
     LIBRARY_KINDS,
@@ -129,13 +132,16 @@ def submit_library(
     *,
     model: str = "",
     payload: Optional[str] = None,
+    asset_name: str = "",
 ) -> EnrichmentJob:
-    """Queue a job that is about the whole library rather than one asset.
-
-    `asset_id` stays null and `asset_name` empty; the activity row reads "Your whole
-    library" on the client side. `model` is recorded at submit time so the row says
-    which model it is filling, the same reason a transcript records the model that
-    produced it.
+    """Queue a job that is not about one existing asset.
+
+    `asset_id` stays null. `asset_name` is usually empty too, and the activity row then
+    reads "Your whole library" on the client side — right for a backfill, wrong for a URL
+    import, which is about one thing that simply does not exist yet. That caller passes
+    the URL, and the job replaces it with the title once it knows one. `model` is
+    recorded at submit time so the row says which model it is filling, the same reason a
+    transcript records the model that produced it.
     """
     job = EnrichmentJob(
         user_id=user_id,
@@ -143,7 +149,7 @@ def submit_library(
         kind=kind,
         status="queued",
         stage="Queued",
-        asset_name="",
+        asset_name=asset_name,
         model=model,
         payload=payload,
     )
@@ -233,6 +239,10 @@ def _run_job(job_id: str) -> None:
             session.add(asset)
             session.commit()
 
+        # An import that stored the site's captions as a transcript, to embed afterwards
+        # the same way a finished transcription is.
+        captioned: Optional[Asset] = None
+
         try:
             if job.kind == KIND_TRANSCRIBE:
                 count = run_transcribe(session, asset, progress)
@@ -278,6 +288,16 @@ def _run_job(job_id: str) -> None:
                     # Surfaced rather than swallowed: a run that quietly skipped three
                     # assets looks identical to one that embedded everything.
                     detail += f", {result.failed} failed"
+            elif job.kind == KIND_IMPORT_URL:
+                imported = run_import_url(session, job, progress)
+                detail = imported.detail
+                captioned = imported.captioned_asset
+                if imported.created_asset_id:
+                    # Merged into the request rather than replacing it, unlike the
+                    # sub-video branch above: the URL and options stay readable on a
+                    # finished row, which is the first thing to look at when an import
+                    # produced something unexpected.
+                    job.payload = _with_created_asset(job.payload, imported.created_asset_id)
             elif job.kind == KIND_HARVEST_ATTRIBUTION:
                 harvested = run_harvest_attribution(session, job.user_id, progress)
                 detail = (
@@ -306,6 +326,8 @@ def _run_job(job_id: str) -> None:
                 # work and put a row in the activity feed saying so. It belongs here the
                 # day page bodies are embedded — see the search gap in plan-of-attack.
                 _chain_embedding(session, asset)
+            elif captioned is not None:
+                _chain_embedding(session, captioned)
 
         except JobCancelled:
             _mark_asset_failed(session, asset, job, status=None)
@@ -348,6 +370,11 @@ def _run_job(job_id: str) -> None:
             set_fields(session, job, status="error", stage="", error_message=message)
             logger.info("Enrichment job %s failed: %s", job_id, message)
 
+        except UrlImportError as exc:
+            message = str(exc)
+            set_fields(session, job, status="error", stage="", error_message=message)
+            logger.info("Enrichment job %s failed: %s", job_id, message)
+
         except TranscriptionError as exc:
             message = str(exc)
             _mark_asset_failed(session, asset, job)
@@ -389,6 +416,18 @@ def _chain_embedding(session: Session, asset: Asset) -> None:
         logger.warning("Could not queue embedding for asset %s", asset.id, exc_info=True)
 
 
+def _with_created_asset(payload: Optional[str], asset_id: str) -> str:
+    """The job's payload with the asset it produced added, for `registry._result_asset_id`."""
+    try:
+        data = json.loads(payload or "{}")
+    except ValueError:
+        data = {}
+    if not isinstance(data, dict):
+        data = {}
+    data["created_asset_id"] = asset_id
+    return json.dumps(data, sort_keys=True)
+
+
 def _mark_asset_failed(session, asset: Optional[Asset], job: EnrichmentJob, status: str | None = "error") -> None:
     """Clear the asset's "running" flag so the UI stops showing a spinner forever."""
     # A whole-library job carries no asset, and the callers now pass None.
diff --git a/backend/app/jobs/registry.py b/backend/app/jobs/registry.py
index a8948b1..c893e3f 100644
--- a/backend/app/jobs/registry.py
+++ b/backend/app/jobs/registry.py
@@ -21,7 +21,7 @@
 from sqlmodel import Session, col, select
 
 from app.jobs.runner import ACTIVE_STATUSES, JobQueue, is_stale
-from app.models.job import KIND_EXTRACT_SUBVIDEO, EnrichmentJob
+from app.models.job import KIND_EXTRACT_SUBVIDEO, KIND_IMPORT_URL, EnrichmentJob
 from app.schemas_jobs import ActivityJobRead
 
 
@@ -41,14 +41,20 @@ def __init__(
         self.queue_for = queue_for
 
 
+# Kinds whose finished payload names the asset they made. Both create a row that did
+# not exist when the job was queued, so `asset_id` cannot carry it: for an extraction it
+# stays pointed at the source, and an import has no asset at all until it is done.
+_CREATES_AN_ASSET = frozenset({KIND_EXTRACT_SUBVIDEO, KIND_IMPORT_URL})
+
+
 def _result_asset_id(job: EnrichmentJob) -> Optional[str]:
-    """The asset a `KIND_EXTRACT_SUBVIDEO` "extract" job created, once it has.
+    """The asset an "extract" sub-video job or a URL import created, once it has.
 
     Best-effort, the same defensive shape `routers/transcripts.py::_words_of` uses to
     read a JSON-as-TEXT column that might be empty, or — for every other kind, whose
     payload means something else entirely — simply not have this key.
     """
-    if job.kind != KIND_EXTRACT_SUBVIDEO or not job.payload:
+    if job.kind not in _CREATES_AN_ASSET or not job.payload:
         return None
     try:
         data = json.loads(job.payload)
diff --git a/backend/app/main.py b/backend/app/main.py
index 409a1e0..b879522 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -7,6 +7,7 @@
 
 import logging
 import os
+import shutil
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
@@ -27,6 +28,7 @@
 from app.routers import clips as clips_router
 from app.routers import embeddings as embeddings_router
 from app.routers import enrichment as enrichment_router
+from app.routers import imports as imports_router
 from app.routers import media as media_router
 from app.routers import providers as providers_router
 from app.routers import search as search_router
@@ -51,6 +53,14 @@ async def lifespan(_app: FastAPI):
             "ffmpeg/ffprobe not found on PATH. Media probing, thumbnails and clip "
             "extraction will be unavailable."
         )
+    # Warned about rather than refused: every other feature works without it. Without
+    # a JavaScript runtime yt-dlp gets almost nothing out of YouTube, and the failure
+    # otherwise surfaces as a vague "format not available" on the first import.
+    if shutil.which("deno") is None:
+        logger.warning(
+            "deno not found on PATH. Importing from YouTube needs it; reinstall "
+            "backend/requirements.txt, which brings it in through yt-dlp[deno]."
+        )
     # Before the job runner, which queries tables of its own: if the schema is behind,
     # one line here beats the same fact arriving as a three-hundred-line traceback on
     # whichever request first touches a table that does not exist yet.
@@ -162,6 +172,7 @@ def me(
 app.include_router(transcripts_router.router, prefix="/api/assets", tags=["transcripts"])
 app.include_router(enrichment_router.router, prefix="/api/assets", tags=["enrichment"])
 app.include_router(clips_router.router, prefix="/api/assets", tags=["clips"])
+app.include_router(imports_router.router, prefix="/api/assets", tags=["imports"])
 app.include_router(activity_router.router, prefix="/api/activity", tags=["activity"])
 app.include_router(search_router.router, prefix="/api/search", tags=["search"])
 app.include_router(embeddings_router.router, prefix="/api/embeddings", tags=["embeddings"])
diff --git a/backend/app/models/job.py b/backend/app/models/job.py
index 1a8d3af..7b40069 100644
--- a/backend/app/models/job.py
+++ b/backend/app/models/job.py
@@ -54,6 +54,12 @@
 # `ENRICHMENT_KINDS` for the same reason as the two above: it calls no provider and
 # costs nothing.
 KIND_HARVEST_ATTRIBUTION = "harvest_attribution"
+# Downloading a video (or a playlist's worth) from a URL with yt-dlp. A library kind
+# rather than a per-asset one because the asset does not exist until the job has run —
+# the URL and options ride in `payload`, and the asset it made comes back as
+# `created_asset_id` there, exactly as an "extract" sub-video's does. Outside
+# `ENRICHMENT_KINDS`: it calls no paid provider. See docs/url-import.md.
+KIND_IMPORT_URL = "import_url"
 
 # Per-asset actions. Everything in here requires an `asset_id`.
 ENRICHMENT_KINDS = frozenset(
@@ -74,7 +80,7 @@
 # change to the dispatch. A bulk run over a selection is here too: it has many assets,
 # which for the purposes of `asset_id` is the same as having none.
 LIBRARY_KINDS = frozenset(
-    {KIND_BACKFILL_EMBEDDINGS, KIND_BULK_ENRICH, KIND_HARVEST_ATTRIBUTION}
+    {KIND_BACKFILL_EMBEDDINGS, KIND_BULK_ENRICH, KIND_HARVEST_ATTRIBUTION, KIND_IMPORT_URL}
 )
 
 
diff --git a/backend/app/routers/imports.py b/backend/app/routers/imports.py
new file mode 100644
index 0000000..6bc4497
--- /dev/null
+++ b/backend/app/routers/imports.py
@@ -0,0 +1,70 @@
+"""Importing media from a URL — YouTube and the other sites yt-dlp knows.
+
+Its own router rather than another endpoint in `assets.py`, mirroring how clips and
+enrichment each got one: the upload path takes bytes, this takes a promise of bytes, and
+nothing about the two requests is shared. Mounted under `/api/assets` all the same,
+because what it makes is an asset.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, status
+from pydantic import BaseModel, Field
+from sqlmodel import Session
+
+from app.auth import CurrentUser
+from app.database import get_session
+from app.enrichment.import_url import ImportRequest
+from app.ingest.ytdlp import MAX_URL, normalise_url
+from app.jobs import enrichment as enrichment_jobs
+from app.jobs.registry import KINDS
+from app.models.job import KIND_IMPORT_URL
+from app.schemas import DataResponse
+from app.schemas_jobs import ActivityJobRead
+
+router = APIRouter()
+
+
+class UrlImportCreate(BaseModel):
+    url: str = Field(min_length=1, max_length=MAX_URL)
+    # Just the soundtrack, as .m4a — a talk or a podcast where the picture is a
+    # static frame, at a tenth of the size.
+    audio_only: bool = False
+    # On by default at the user's request; off routes the uploader's tags through the
+    # suggestion queue instead. See `enrichment/import_url.py::_apply_tags`.
+    apply_tags: bool = True
+    chapters_as_clips: bool = True
+
+
+@router.post(
+    "/import", response_model=DataResponse[ActivityJobRead], status_code=status.HTTP_202_ACCEPTED
+)
+def start_url_import(
+    payload: UrlImportCreate,
+    user: CurrentUser,
+    session: Session = Depends(get_session),
+) -> DataResponse[ActivityJobRead]:
+    """Queue an import. Returns the job, which the activity feed then follows.
+
+    Nothing here touches the network beyond the SSRF guard's DNS lookup. Reading a page
+    with yt-dlp takes seconds — longer when YouTube wants a JavaScript challenge solved —
+    and a request that did it inline would hold the browser for all of it, then do the
+    work again in the job. Whether the link is a video, a playlist, or nothing at all is
+    the job's first step, and its answer arrives the way every other job's does.
+
+    No duplicate check either, for the same reason: `youtu.be/x` and
+    `youtube.com/watch?v=x` are the same video, and only the site can say so. The job
+    finds an existing copy once it knows the canonical address, and finishes pointing at
+    it rather than downloading it twice.
+    """
+    url = normalise_url(payload.url)
+    request = ImportRequest(
+        url=url,
+        audio_only=payload.audio_only,
+        apply_tags=payload.apply_tags,
+        chapters_as_clips=payload.chapters_as_clips,
+    )
+    job = enrichment_jobs.submit_library(
+        session, user.id, KIND_IMPORT_URL, payload=request.encode(), asset_name=url[:255]
+    )
+    return DataResponse(data=KINDS["enrichment"].to_activity(job))
diff --git a/backend/app/services/assets.py b/backend/app/services/assets.py
index ffebaa8..7e28627 100644
--- a/backend/app/services/assets.py
+++ b/backend/app/services/assets.py
@@ -1,8 +1,8 @@
 """Turning an upload into a catalogued asset, and reading one back out.
 
 Kept out of the router so the pipeline can be tested without HTTP and reused by the
-later milestones that create assets without an upload — an extracted sub-video (M7) and
-an AI generation (M8) both land here.
+later milestones that create assets without an upload — an extracted sub-video (M7), a
+URL import, and an AI generation (M8) all land here.
 """
 
 from __future__ import annotations
@@ -10,6 +10,7 @@
 import json
 import logging
 import mimetypes
+from pathlib import Path
 from typing import Any, AsyncIterator, Iterable, Optional
 
 from sqlalchemy import and_, func, not_, or_
@@ -74,22 +75,85 @@ async def ingest_upload(
     or is slow leaves a poorer asset, never a lost one. This is FR 6.1.2 and 6.1.3:
     nothing blocks ingestion.
     """
+    asset_type = _require_supported(filename)
+    stored = await storage.write_stream(new_key(user_id, extension_of(filename)), chunks)
+    return _catalogue(
+        session,
+        storage,
+        stored,
+        user_id=user_id,
+        filename=filename,
+        asset_type=asset_type,
+        source=source,
+        content_type=content_type,
+    )
+
+
+def ingest_file(
+    session: Session,
+    storage: LocalStorage,
+    *,
+    user_id: str,
+    source_path: Path,
+    filename: str,
+    name: Optional[str] = None,
+    source: str = SOURCE_UPLOAD,
+    content_type: Optional[str] = None,
+) -> Asset:
+    """`ingest_upload` for bytes that are already a file on disk.
+
+    A worker thread's version: a URL import downloads to a temp directory first (yt-dlp
+    has to, to merge separate audio and video streams), and has no async iterator to
+    offer. Everything after the bytes land is `_catalogue`, shared, so an import is
+    probed, thumbnailed, harvested, indexed and queued for transcription by exactly the
+    code an upload is — not by a second copy of it that drifts.
+
+    `name` overrides the filename-derived default. An import knows the real title, and
+    deriving it back out of a filename would lose anything the filename could not hold.
+    """
+    asset_type = _require_supported(filename)
+    stored = storage.write_file(new_key(user_id, extension_of(filename)), source_path)
+    return _catalogue(
+        session,
+        storage,
+        stored,
+        user_id=user_id,
+        filename=filename,
+        asset_type=asset_type,
+        source=source,
+        content_type=content_type,
+        name=name,
+    )
+
+
+def _require_supported(filename: str) -> str:
     asset_type = asset_type_for(filename)
     if asset_type is None:
         raise UnsupportedFile(filename)
+    return asset_type
 
-    extension = extension_of(filename)
-    key = new_key(user_id, extension)
-    stored = await storage.write_stream(key, chunks)
 
-    original_name = sanitize_original_name(filename)
+def _catalogue(
+    session: Session,
+    storage: LocalStorage,
+    stored: StoredFile,
+    *,
+    user_id: str,
+    filename: str,
+    asset_type: str,
+    source: str,
+    content_type: Optional[str],
+    name: Optional[str] = None,
+) -> Asset:
+    """Everything that happens once the bytes are safely stored."""
+    extension = extension_of(filename)
     asset = Asset(
         user_id=user_id,
-        name=display_name_from(filename),
+        name=(name or "").strip()[:255] or display_name_from(filename),
         asset_type=asset_type,
         source=source,
         storage_key=stored.key,
-        original_name=original_name,
+        original_name=sanitize_original_name(filename),
         mime_type=content_type or mimetypes.guess_type(filename)[0],
         file_format=extension.lstrip(".") or None,
         size_bytes=stored.size_bytes,
diff --git a/backend/requirements.txt b/backend/requirements.txt
index 3901f15..245bd36 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -34,3 +34,14 @@ pypdfium2==4.30.0
 python-docx==1.2.0
 python-pptx==1.0.2
 openpyxl==3.1.5
+# Importing video from YouTube and the ~1,800 other sites it knows (docs/url-import.md).
+#
+# `default` pulls yt-dlp-ejs, the scripts that solve YouTube's JavaScript challenges, and
+# `deno` installs the runtime that runs them — since late 2025 YouTube serves almost no
+# downloadable formats to a client that cannot. Both ship manylinux wheels for x86_64
+# and aarch64, so nothing compiles on the pinned 3.13.
+#
+# Pinned like everything else here, with one difference worth knowing: YouTube changes
+# under yt-dlp every few weeks, so this pin *will* start failing on its own schedule. The
+# fix is always the same — bump it to the latest release and `docker compose up --build`.
+yt-dlp[default,deno]==2026.8.19
diff --git a/backend/tests/test_captions.py b/backend/tests/test_captions.py
new file mode 100644
index 0000000..09fda8d
--- /dev/null
+++ b/backend/tests/test_captions.py
@@ -0,0 +1,150 @@
+"""Turning a site's VTT captions into transcript segments (`ingest/captions.py`)."""
+
+import pytest
+
+from app.ingest.captions import MAX_SEGMENT_SECONDS, parse_vtt
+
+# The shape YouTube's auto-captions actually arrive in: a rolling two-line display where
+# each cue repeats the previous line, per-word karaoke timestamps inside `<c>` spans, and
+# a 10ms cue between them showing the finished line alone.
+ROLLING_AUTO_CAPTIONS = """WEBVTT
+Kind: captions
+Language: en
+
+00:00:00.000 --> 00:00:02.500 align:start position:0%
+we<00:00:00.400><c> are</c><00:00:00.800><c> talking</c><00:00:01.200><c> about</c>
+
+00:00:02.500 --> 00:00:02.510 align:start position:0%
+we are talking about
+\x20
+
+00:00:02.510 --> 00:00:05.000 align:start position:0%
+we are talking about
+nano<00:00:03.000><c> weapons</c><00:00:03.500><c> today</c>
+
+00:00:05.000 --> 00:00:05.010 align:start position:0%
+nano weapons today
+\x20
+
+00:00:05.010 --> 00:00:07.000 align:start position:0%
+nano weapons today
+and<00:00:05.500><c> their</c><00:00:06.000><c> deployment</c>
+"""
+
+
+def test_rolling_auto_captions_are_read_once_each():
+    """The whole reason the parser deduplicates. Read naively, every line of an
+    auto-captioned video appears two or three times — a transcript that says everything
+    twice, and a search snippet that repeats itself."""
+    segments = parse_vtt(ROLLING_AUTO_CAPTIONS)
+    text = " ".join(s.text for s in segments)
+
+    assert text == "we are talking about nano weapons today and their deployment"
+    assert text.count("nano weapons") == 1
+
+
+def test_a_repeated_line_keeps_its_first_start_and_its_last_end():
+    segments = parse_vtt(ROLLING_AUTO_CAPTIONS)
+
+    assert segments[0].start == 0.0
+    assert segments[-1].end == 7.0
+
+
+def test_inline_markup_and_entities_are_not_speech():
+    vtt = """WEBVTT
+
+00:00:01.000 --> 00:00:03.000
+<v Speaker>Tom &amp; <i>Jerry</i> &gt; everyone.</v>
+"""
+    [segment] = parse_vtt(vtt)
+    assert segment.text == "Tom & Jerry > everyone."
+
+
+def test_sound_annotations_are_dropped():
+    """`[Music]` is not what anybody said, and indexing it makes every video with a
+    sting match a search for music."""
+    vtt = """WEBVTT
+
+00:00:00.000 --> 00:00:02.000
+[Music]
+
+00:00:02.000 --> 00:00:04.000
+Welcome back.
+
+00:00:04.000 --> 00:00:05.000
+(applause)
+"""
+    assert [s.text for s in parse_vtt(vtt)] == ["Welcome back."]
+
+
+def test_punctuated_captions_split_at_sentences():
+    vtt = """WEBVTT
+
+1
+00:00:00.000 --> 00:00:02.000
+This is the first sentence.
+
+2
+00:00:02.000 --> 00:00:03.000
+And here is
+
+3
+00:00:03.000 --> 00:00:04.500
+the second one?
+"""
+    segments = parse_vtt(vtt)
+    assert [s.text for s in segments] == [
+        "This is the first sentence.",
+        "And here is the second one?",
+    ]
+    assert (segments[1].start, segments[1].end) == (2.0, 4.5)
+
+
+def test_unpunctuated_captions_are_cut_before_they_run_on():
+    """Auto-captions mostly lack punctuation, so without a length cap the whole video
+    would be one segment — one search hit with one timestamp for an hour of speech."""
+    cues = "\n\n".join(
+        f"00:00:{i * 4:02d}.000 --> 00:00:{i * 4 + 4:02d}.000\nwords without an ending {i}"
+        for i in range(12)
+    )
+    segments = parse_vtt(f"WEBVTT\n\n{cues}\n")
+
+    assert len(segments) > 1
+    for segment in segments:
+        assert segment.end - segment.start <= MAX_SEGMENT_SECONDS + 4
+
+
+def test_a_pause_starts_a_new_segment():
+    vtt = """WEBVTT
+
+00:00:00.000 --> 00:00:01.000
+before the break
+
+00:00:10.000 --> 00:00:11.000
+after the break
+"""
+    assert [s.text for s in parse_vtt(vtt)] == ["before the break", "after the break"]
+
+
+def test_hours_and_comma_decimals_are_understood():
+    vtt = """WEBVTT
+
+01:02:03,500 --> 01:02:05,000
+Late in a long interview.
+"""
+    [segment] = parse_vtt(vtt)
+    assert segment.start == pytest.approx(3723.5)
+    assert segment.end == pytest.approx(3725.0)
+
+
+@pytest.mark.parametrize("text", ["", "WEBVTT\n", "not a caption file at all", "WEBVTT\n\nNOTE only a note\n"])
+def test_nothing_readable_is_no_segments(text):
+    assert parse_vtt(text) == []
+
+
+def test_segments_carry_no_invented_word_timings():
+    """Captions time lines, not words. An empty list is honest; spreading a line's
+    duration evenly over its words would put click-to-seek a second or two off."""
+    [segment] = parse_vtt("WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nHello there.\n")
+    assert segment.words == []
+    assert segment.speaker is None
diff --git a/backend/tests/test_imports_api.py b/backend/tests/test_imports_api.py
new file mode 100644
index 0000000..0aa8a49
--- /dev/null
+++ b/backend/tests/test_imports_api.py
@@ -0,0 +1,136 @@
+"""`POST /api/assets/import` — queueing an import, and what it refuses up front."""
+
+import json
+import socket
+
+import pytest
+from sqlmodel import select
+
+from app.models.job import KIND_IMPORT_URL, EnrichmentJob
+
+
+def _resolving_to(address):
+    def fake_getaddrinfo(host, port, *args, **kwargs):
+        return [(socket.AF_INET, socket.SOCK_STREAM, 6, "", (address, 0))]
+
+    return fake_getaddrinfo
+
+
+@pytest.fixture(autouse=True)
+def public_dns(monkeypatch):
+    """Every name resolves somewhere public, so these tests never touch real DNS."""
+    monkeypatch.setattr(socket, "getaddrinfo", _resolving_to("93.184.216.34"))
+
+
+def _job(session, job_id):
+    return session.get(EnrichmentJob, job_id)
+
+
+def test_an_import_is_queued_as_a_job(auth_client, session):
+    response = auth_client.post(
+        "/api/assets/import", json={"url": "https://www.youtube.com/watch?v=abc123"}
+    )
+
+    assert response.status_code == 202
+    body = response.json()["data"]
+    assert body["action"] == KIND_IMPORT_URL
+    assert body["status"] == "queued"
+    assert body["asset_id"] is None
+    # Not "" — that renders as "Your whole library" in the activity feed.
+    assert body["asset_name"] == "https://www.youtube.com/watch?v=abc123"
+
+    payload = json.loads(_job(session, body["id"]).payload)
+    assert payload == {
+        "url": "https://www.youtube.com/watch?v=abc123",
+        "audio_only": False,
+        "apply_tags": True,
+        "chapters_as_clips": True,
+        "depth": 0,
+    }
+
+
+def test_options_are_carried_to_the_job(auth_client, session):
+    response = auth_client.post(
+        "/api/assets/import",
+        json={
+            "url": "https://youtu.be/abc123",
+            "audio_only": True,
+            "apply_tags": False,
+            "chapters_as_clips": False,
+        },
+    )
+    payload = json.loads(_job(session, response.json()["data"]["id"]).payload)
+    assert payload["audio_only"] is True
+    assert payload["apply_tags"] is False
+    assert payload["chapters_as_clips"] is False
+
+
+@pytest.mark.parametrize(
+    ("pasted", "stored"),
+    [
+        ("youtu.be/abc123", "https://youtu.be/abc123"),
+        ("  https://youtu.be/abc123  ", "https://youtu.be/abc123"),
+        ("http://www.youtube.com/watch?v=abc123", "https://www.youtube.com/watch?v=abc123"),
+        ("HTTP://rumble.com/v1-x.html", "https://rumble.com/v1-x.html"),
+    ],
+)
+def test_links_are_normalised_the_way_people_paste_them(auth_client, session, pasted, stored):
+    response = auth_client.post("/api/assets/import", json={"url": pasted})
+    assert response.status_code == 202
+    assert json.loads(_job(session, response.json()["data"]["id"]).payload)["url"] == stored
+
+
+@pytest.mark.parametrize(
+    "url",
+    ["ftp://example.com/video.mp4", "file:///etc/passwd", "javascript:alert(1)", "mailto:a@b.com"],
+)
+def test_non_web_links_are_refused(auth_client, url):
+    response = auth_client.post("/api/assets/import", json={"url": url})
+    assert response.status_code == 400
+    assert response.json()["detail"]["code"] == "invalid_url"
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "https://127.0.0.1/video",
+        "https://localhost/video",
+        "https://169.254.169.254/latest/meta-data/",
+        "http://10.0.0.5:8080/admin",
+    ],
+)
+def test_internal_addresses_are_refused(auth_client, url):
+    response = auth_client.post("/api/assets/import", json={"url": url})
+    assert response.status_code == 400
+    assert response.json()["detail"]["code"] == "ssrf_blocked"
+
+
+def test_a_name_that_resolves_inward_is_refused(auth_client, monkeypatch):
+    """The case a literal-IP check alone misses: a name the attacker controls."""
+    monkeypatch.setattr(socket, "getaddrinfo", _resolving_to("10.1.2.3"))
+    response = auth_client.post(
+        "/api/assets/import", json={"url": "https://innocent-looking.example/video"}
+    )
+    assert response.status_code == 400
+    assert response.json()["detail"]["code"] == "ssrf_blocked"
+
+
+def test_a_refused_link_queues_nothing(auth_client, session):
+    auth_client.post("/api/assets/import", json={"url": "https://127.0.0.1/video"})
+    assert session.exec(select(EnrichmentJob)).all() == []
+
+
+@pytest.mark.parametrize("body", [{}, {"url": ""}, {"url": "https://x.com/" + "a" * 2100}])
+def test_malformed_requests_are_422(auth_client, body):
+    assert auth_client.post("/api/assets/import", json=body).status_code == 422
+
+
+def test_whitespace_only_is_refused(auth_client):
+    response = auth_client.post("/api/assets/import", json={"url": "   "})
+    assert response.status_code == 400
+    assert response.json()["detail"]["code"] == "invalid_url"
+
+
+def test_importing_requires_authentication(client):
+    response = client.post("/api/assets/import", json={"url": "https://youtu.be/abc123"})
+    assert response.status_code == 401
diff --git a/backend/tests/test_url_import.py b/backend/tests/test_url_import.py
new file mode 100644
index 0000000..1591fbf
--- /dev/null
+++ b/backend/tests/test_url_import.py
@@ -0,0 +1,718 @@
+"""The import_url job, end to end, with yt-dlp replaced and everything else real.
+
+`FakeYoutubeDL` stands in for the network: it answers `extract_info` from a table of
+info dicts and, when asked to download, writes real fixture media where yt-dlp would.
+So ingest, ffprobe, thumbnails, clipping, the transcript writer and the keyword index
+all run for real — the only thing assumed is what the site says. That assumption is
+also the one thing this suite cannot check, since no CI run should depend on YouTube;
+the options passed to yt-dlp are asserted on instead, which is as close as a hermetic
+test gets.
+"""
+
+import copy
+import json
+import shutil
+import socket
+from pathlib import Path
+
+import pytest
+from sqlmodel import col, select
+from yt_dlp.utils import DownloadError
+
+from app.ingest import ytdlp
+from app.jobs import enrichment as enrichment_jobs
+from app.jobs.runner import JobCancelled
+from app.media_tools import ffmpeg_available
+from app.models.asset import Asset
+from app.models.job import KIND_EMBED, KIND_IMPORT_URL, KIND_TRANSCRIBE, EnrichmentJob
+from app.models.suggestion import KIND_TAG, Suggestion
+from app.models.transcript import TranscriptSegment
+from app.embeddings import PROVIDER_OLLAMA
+from app.services import tags as tag_service
+from app.settings_store import DEEPGRAM_API_KEY, EMBEDDING_PROVIDER, set_setting
+
+FIXTURES = Path(__file__).parent / "fixtures"
+TEST_USER = "user-under-test"
+VIDEO_URL = "https://www.youtube.com/watch?v=abc123"
+
+needs_ffmpeg = pytest.mark.skipif(not ffmpeg_available(), reason="ffmpeg not on PATH")
+
+CAPTIONS_VTT = """WEBVTT
+Kind: captions
+Language: en
+
+00:00:00.000 --> 00:00:01.000
+We are talking about nano weapons.
+
+00:00:01.000 --> 00:00:02.000
+And their deployment.
+"""
+
+
+def video_info(**overrides):
+    """What yt-dlp says about one YouTube video, trimmed to the keys the importer reads."""
+    info = {
+        "_type": "video",
+        "id": "abc123",
+        "title": "Giordano on neuroweapons",
+        "description": "A lecture at the Naval War College.\nhttps://example.org/notes",
+        "webpage_url": VIDEO_URL,
+        "channel": "Lecture Archive",
+        "uploader": "Lecture Archive",
+        "upload_date": "20171205",
+        "license": "Creative Commons Attribution license (reuse allowed)",
+        "tags": ["Neuroscience", "  national   security ", "neuroscience", "x" * 90],
+        "chapters": [
+            {"start_time": 0.0, "end_time": 1.0, "title": "Opening"},
+            # Past the 2s fixture's end: must be clamped, not refused.
+            {"start_time": 1.0, "end_time": 3.0, "title": "Discussion"},
+        ],
+        "language": "en",
+        "subtitles": {},
+        "automatic_captions": {"en-orig": [{"ext": "vtt"}], "fr": [{"ext": "vtt"}]},
+        "extractor_key": "Youtube",
+        "live_status": "not_live",
+    }
+    info.update(overrides)
+    return info
+
+
+class FakeYoutubeDL:
+    """Answers from `infos`; records every construction in `made`."""
+
+    infos: dict = {}
+    made: list = []
+    # When set, raised from `extract_info` for the matching URL.
+    errors: dict = {}
+
+    def __init__(self, params):
+        self.params = params
+        FakeYoutubeDL.made.append(params)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        return False
+
+    def extract_info(self, url, download=False):
+        if url in FakeYoutubeDL.errors:
+            raise FakeYoutubeDL.errors[url]
+        info = copy.deepcopy(FakeYoutubeDL.infos[url])
+        if not download:
+            return info
+
+        workdir = Path(self.params["paths"]["home"])
+        for hook in self.params.get("progress_hooks", []):
+            hook(
+                {
+                    "status": "downloading",
+                    "downloaded_bytes": 50,
+                    "total_bytes": 100,
+                    "info_dict": {"vcodec": "avc1"},
+                }
+            )
+
+        audio_only = self.params.get("format", "").startswith("ba")
+        if audio_only:
+            media = workdir / "media.m4a"
+            shutil.copyfile(FIXTURES / "sample_audio.mp3", media)
+        else:
+            media = workdir / "media.mp4"
+            shutil.copyfile(FIXTURES / "sample_video.mp4", media)
+        shutil.copyfile(FIXTURES / "sample_image.jpg", workdir / "thumb.jpg")
+
+        for lang in self.params.get("subtitleslangs") or []:
+            (workdir / f"captions.{lang}.vtt").write_text(CAPTIONS_VTT)
+
+        info["requested_downloads"] = [{"filepath": str(media)}]
+        return info
+
+
+@pytest.fixture(autouse=True)
+def fake_ytdlp(monkeypatch):
+    FakeYoutubeDL.infos = {VIDEO_URL: video_info()}
+    FakeYoutubeDL.made = []
+    FakeYoutubeDL.errors = {}
+    monkeypatch.setattr(ytdlp.yt_dlp, "YoutubeDL", FakeYoutubeDL)
+    # Every name resolves somewhere public, so the SSRF guard never touches real DNS.
+    monkeypatch.setattr(
+        socket,
+        "getaddrinfo",
+        lambda host, port, *a, **k: [(socket.AF_INET, socket.SOCK_STREAM, 6, "", ("93.184.216.34", 0))],
+    )
+    return FakeYoutubeDL
+
+
+def _import(library, session, monkeypatch, url=VIDEO_URL, **options):
+    """Queue through the real endpoint, then run the worker on it directly."""
+    response = library.post("/api/assets/import", json={"url": url, **options})
+    assert response.status_code == 202, response.text
+    job_id = response.json()["data"]["id"]
+    _run(session, monkeypatch, job_id)
+    return job_id
+
+
+def _run(session, monkeypatch, job_id):
+    queue = enrichment_jobs.queue()
+    monkeypatch.setattr(queue, "engine", session.get_bind())
+    enrichment_jobs._run_job(job_id)
+    session.expire_all()
+    return session.get(EnrichmentJob, job_id)
+
+
+def _activity(library, job_id):
+    return library.get(f"/api/activity/enrichment/{job_id}").json()["data"]
+
+
+def _only_import(session):
+    rows = session.exec(select(Asset).where(Asset.source == "url")).all()
+    assert len(rows) == 1
+    return rows[0]
+
+
+# ─── the happy path ──────────────────────────────────────────────────────────
+
+
+@needs_ffmpeg
+def test_a_video_is_imported_with_what_the_site_said_about_it(library, session, monkeypatch):
+    job_id = _import(library, session, monkeypatch)
+
+    job = _activity(library, job_id)
+    assert job["status"] == "done", job["error_message"]
+    asset = _only_import(session)
+    assert job["result_asset_id"] == asset.id
+    assert job["asset_name"] == "Giordano on neuroweapons"
+
+    assert asset.name == "Giordano on neuroweapons"
+    assert asset.asset_type == "video"
+    assert asset.source == "url"
+    assert asset.original_name == "Giordano on neuroweapons.mp4"
+    assert asset.duration_seconds == pytest.approx(2.0, abs=0.2)
+    assert asset.description.startswith("A lecture at the Naval War College.")
+
+    assert asset.source_url == VIDEO_URL
+    assert asset.publisher == "Lecture Archive"
+    assert asset.source_title == "Giordano on neuroweapons"
+    assert asset.published_date == "2017-12-05"
+    assert asset.license == "Creative Commons Attribution license (reuse allowed)"
+    assert asset.retrieved_at is not None
+    # The channel is the outlet, not the speaker: a creator copied from it would be
+    # the confidently wrong citation M10 exists to prevent.
+    assert asset.creator is None
+
+
+@needs_ffmpeg
+def test_site_metadata_is_stamped_embedded_not_human(library, session, monkeypatch):
+    _import(library, session, monkeypatch)
+    provenance = json.loads(_only_import(session).field_provenance)
+
+    for name in ("description", "publisher", "source_url", "published_date", "retrieved_at"):
+        assert provenance[name] == "embedded"
+
+
+@needs_ffmpeg
+def test_the_finished_asset_is_readable_through_the_api(library, session, monkeypatch):
+    job_id = _import(library, session, monkeypatch)
+    asset_id = _activity(library, job_id)["result_asset_id"]
+
+    body = library.get(f"/api/assets/{asset_id}").json()["data"]
+    assert body["source"] == "url"
+    assert body["thumb_url"]
+    assert body["credit"] == (
+        "Giordano on neuroweapons — Lecture Archive — 2017-12-05 — "
+        "Creative Commons Attribution license (reuse allowed)"
+    )
+
+
+@needs_ffmpeg
+def test_the_import_is_findable_by_its_channel(library, session, monkeypatch):
+    _import(library, session, monkeypatch)
+    listing = library.get("/api/assets", params={"publisher": "lecture archive"}).json()
+    # The parent and both chapter clips, which inherit its publisher.
+    assert listing["total"] == 3
+
+
+# ─── what gets passed to yt-dlp ──────────────────────────────────────────────
+
+
+@needs_ffmpeg
+def test_named_sites_only_and_the_quality_cap(library, session, monkeypatch):
+    _import(library, session, monkeypatch)
+
+    for params in FakeYoutubeDL.made:
+        assert params["allowed_extractors"] == ["default", "-generic"]
+        assert params["noplaylist"] is True
+        assert params["ignoreerrors"] is False
+
+    download = FakeYoutubeDL.made[-1]
+    assert download["format"] == "bv*+ba/b"
+    assert download["format_sort"] == ["res:1080", "vcodec:h264", "acodec:m4a"]
+    assert download["merge_output_format"] == "mp4"
+    # Fixed output names: a filename built from the title is built from text the site
+    # controls.
+    assert download["outtmpl"]["default"] == "media.%(ext)s"
+
+
+@needs_ffmpeg
+def test_the_quality_cap_follows_the_setting(library, session, monkeypatch):
+    from app.config import settings
+
+    monkeypatch.setattr(settings, "url_import_max_height", 720)
+    _import(library, session, monkeypatch)
+    assert FakeYoutubeDL.made[-1]["format_sort"][0] == "res:720"
+
+
+@needs_ffmpeg
+def test_a_cookies_file_is_copied_not_used_in_place(library, session, monkeypatch, tmp_path):
+    """yt-dlp writes the jar back out on close, which fails on the read-only mount the
+    docs recommend — and would otherwise rewrite the user's own file."""
+    from app.config import settings
+
+    cookies = tmp_path / "cookies.txt"
+    cookies.write_text("# Netscape HTTP Cookie File\n")
+    monkeypatch.setattr(settings, "url_import_cookies_file", str(cookies))
+
+    _import(library, session, monkeypatch)
+
+    used = FakeYoutubeDL.made[-1]["cookiefile"]
+    assert used != str(cookies)
+    assert Path(used).name == "cookies.txt"
+
+
+def test_a_missing_cookies_file_fails_with_a_message(library, session, monkeypatch):
+    from app.config import settings
+
+    monkeypatch.setattr(settings, "url_import_cookies_file", "/nowhere/cookies.txt")
+    job_id = _import(library, session, monkeypatch)
+
+    job = _activity(library, job_id)
+    assert job["status"] == "error"
+    assert "URL_IMPORT_COOKIES_FILE" in job["error_message"]
+
+
+# ─── tags ────────────────────────────────────────────────────────────────────
+
+
+@needs_ffmpeg
+def test_uploader_tags_are_applied_by_default(library, session, monkeypatch):
+    _import(library, session, monkeypatch)
+    asset = _only_import(session)
+
+    names = sorted(t.name for t in tag_service.tags_for(session, asset.id))
+    # Whitespace collapsed, the case-insensitive duplicate dropped, and the 90-character
+    # one left out as longer than any tag may be.
+    assert names == ["Neuroscience", "national security"]
+
+
+@needs_ffmpeg
+def test_applied_tags_are_searchable(library, session, monkeypatch):
+    _import(library, session, monkeypatch)
+    listing = library.get("/api/assets", params={"tag": "national security"}).json()
+    assert listing["total"] == 1
+
+
+@needs_ffmpeg
+def test_tags_can_be_offered_as_suggestions_instead(library, session, monkeypatch):
+    _import(library, session, monkeypatch, apply_tags=False)
+    asset = _only_import(session)
+
+    assert tag_service.tags_for(session, asset.id) == []
+    pending = session.exec(
+        select(Suggestion).where(Suggestion.asset_id == asset.id, Suggestion.kind == KIND_TAG)
+    ).all()
+    assert sorted(s.value for s in pending) == ["Neuroscience", "national security"]
+    assert all(s.model == "youtube tags" for s in pending)
+
+
+# ─── chapters ────────────────────────────────────────────────────────────────
+
+
+@needs_ffmpeg
+def test_chapters_become_clips(library, session, monkeypatch):
+    _import(library, session, monkeypatch)
+    parent = _only_import(session)
+
+    clips = session.exec(
+        select(Asset).where(Asset.parent_asset_id == parent.id).order_by(col(Asset.in_point))
+    ).all()
+    assert [c.name for c in clips] == [
+        "Opening — Giordano on neuroweapons",
+        "Discussion — Giordano on neuroweapons",
+    ]
+    assert all(c.source == "clip" and c.storage_key is None for c in clips)
+    assert (clips[0].in_point, clips[0].out_point) == (0.0, 1.0)
+    # Clamped to the file's real length rather than refused for running past it.
+    assert clips[1].out_point == pytest.approx(parent.duration_seconds)
+
+
+@needs_ffmpeg
+def test_chapter_clips_can_be_turned_off(library, session, monkeypatch):
+    _import(library, session, monkeypatch, chapters_as_clips=False)
+    parent = _only_import(session)
+    assert session.exec(select(Asset).where(Asset.parent_asset_id == parent.id)).all() == []
+
+
+@needs_ffmpeg
+def test_a_single_chapter_is_not_a_clip(library, session, monkeypatch):
+    """One chapter spanning the video would be a clip identical to its parent."""
+    FakeYoutubeDL.infos[VIDEO_URL] = video_info(
+        chapters=[{"start_time": 0.0, "end_time": 2.0, "title": "Everything"}]
+    )
+    _import(library, session, monkeypatch)
+    parent = _only_import(session)
+    assert session.exec(select(Asset).where(Asset.parent_asset_id == parent.id)).all() == []
+
+
+# ─── captions and transcription ──────────────────────────────────────────────
+
+
+@needs_ffmpeg
+def test_without_deepgram_the_captions_become_the_transcript(library, session, monkeypatch):
+    job_id = _import(library, session, monkeypatch)
+    asset = _only_import(session)
+
+    # The original-language speech track, not the French auto-translation beside it.
+    assert FakeYoutubeDL.made[-1]["subtitleslangs"] == ["en-orig"]
+    assert FakeYoutubeDL.made[-1]["writeautomaticsub"] is True
+
+    segments = session.exec(
+        select(TranscriptSegment)
+        .where(TranscriptSegment.asset_id == asset.id)
+        .order_by(col(TranscriptSegment.idx))
+    ).all()
+    assert [s.text for s in segments] == [
+        "We are talking about nano weapons.",
+        "And their deployment.",
+    ]
+    assert asset.transcript_status == "done"
+    assert asset.transcript_model == "youtube-auto-captions"
+    assert asset.transcript_language == "en"
+    assert "captions as transcript" in _activity(library, job_id)["detail"]
+
+
+@needs_ffmpeg
+def test_caption_text_is_keyword_searchable(library, session, monkeypatch):
+    _import(library, session, monkeypatch)
+    results = library.get("/api/search", params={"q": "nano weapons"}).json()["data"]
+    assert results and results[0]["start_time"] == 0.0
+
+
+@needs_ffmpeg
+def test_captions_chain_an_embedding_like_a_transcript_does(library, session, monkeypatch):
+    set_setting(session, TEST_USER, EMBEDDING_PROVIDER, PROVIDER_OLLAMA)
+    _import(library, session, monkeypatch)
+    asset = _only_import(session)
+
+    embeds = session.exec(
+        select(EnrichmentJob).where(
+            EnrichmentJob.asset_id == asset.id, EnrichmentJob.kind == KIND_EMBED
+        )
+    ).all()
+    assert len(embeds) == 1
+
+
+@needs_ffmpeg
+def test_hand_written_captions_are_preferred(library, session, monkeypatch):
+    FakeYoutubeDL.infos[VIDEO_URL] = video_info(subtitles={"en-GB": [{"ext": "vtt"}]})
+    _import(library, session, monkeypatch)
+
+    download = FakeYoutubeDL.made[-1]
+    assert download["subtitleslangs"] == ["en-GB"]
+    assert download["writesubtitles"] is True
+    assert _only_import(session).transcript_model == "youtube-captions"
+
+
+@needs_ffmpeg
+def test_with_deepgram_the_captions_are_not_fetched(library, session, monkeypatch):
+    """The user's rule: Deepgram when there is a key. Its transcript is diarised and
+    word-timed, and the upload chain queues it on its own."""
+    set_setting(session, TEST_USER, DEEPGRAM_API_KEY, "dg-test-key")
+    _import(library, session, monkeypatch)
+    asset = _only_import(session)
+
+    assert "subtitleslangs" not in FakeYoutubeDL.made[-1]
+    assert session.exec(
+        select(TranscriptSegment).where(TranscriptSegment.asset_id == asset.id)
+    ).all() == []
+    transcribe = session.exec(
+        select(EnrichmentJob).where(
+            EnrichmentJob.asset_id == asset.id, EnrichmentJob.kind == KIND_TRANSCRIBE
+        )
+    ).all()
+    assert len(transcribe) == 1
+
+
+@needs_ffmpeg
+def test_no_captions_at_all_is_not_a_failure(library, session, monkeypatch):
+    FakeYoutubeDL.infos[VIDEO_URL] = video_info(automatic_captions={}, subtitles={})
+    job_id = _import(library, session, monkeypatch)
+
+    assert _activity(library, job_id)["status"] == "done"
+    assert _only_import(session).transcript_status is None
+
+
+# ─── audio only ──────────────────────────────────────────────────────────────
+
+
+@needs_ffmpeg
+def test_audio_only_imports_an_audio_asset(library, session, monkeypatch):
+    _import(library, session, monkeypatch, audio_only=True)
+    asset = _only_import(session)
+
+    download = FakeYoutubeDL.made[-1]
+    assert download["format"].startswith("ba")
+    assert download["postprocessors"][0] == {
+        "key": "FFmpegExtractAudio",
+        "preferredcodec": "m4a",
+    }
+    assert asset.asset_type == "audio"
+    assert asset.file_format == "m4a"
+    # The site's thumbnail, which is the only picture an audio asset gets.
+    assert asset.thumb_key
+
+
+# ─── duplicates ──────────────────────────────────────────────────────────────
+
+
+@needs_ffmpeg
+def test_importing_the_same_video_twice_points_at_the_first(library, session, monkeypatch):
+    first = _activity(library, _import(library, session, monkeypatch))["result_asset_id"]
+    downloads_before = sum(1 for p in FakeYoutubeDL.made if "paths" in p)
+
+    job_id = _import(library, session, monkeypatch)
+    job = _activity(library, job_id)
+
+    assert job["status"] == "done"
+    assert job["detail"] == "Already in your library"
+    assert job["result_asset_id"] == first
+    assert sum(1 for p in FakeYoutubeDL.made if "paths" in p) == downloads_before
+    assert len(session.exec(select(Asset).where(Asset.source == "url")).all()) == 1
+
+
+# ─── playlists ───────────────────────────────────────────────────────────────
+
+PLAYLIST_URL = "https://www.youtube.com/playlist?list=PL123"
+
+
+def _playlist(*entries, **overrides):
+    info = {
+        "_type": "playlist",
+        "title": "Conference 2017",
+        "entries": [{"_type": "url", "url": url, "title": title} for url, title in entries],
+    }
+    info.update(overrides)
+    return info
+
+
+def _children(session, parent_id):
+    """Imports a playlist queued — the ones whose payload says they came from one."""
+    return [
+        job
+        for job in session.exec(
+            select(EnrichmentJob)
+            .where(EnrichmentJob.kind == KIND_IMPORT_URL)
+            .order_by(col(EnrichmentJob.created_at))
+        ).all()
+        if job.id != parent_id and json.loads(job.payload).get("depth", 0) >= 1
+    ]
+
+
+def test_a_playlist_queues_one_import_per_video(library, session, monkeypatch):
+    FakeYoutubeDL.infos[PLAYLIST_URL] = _playlist(
+        ("https://www.youtube.com/watch?v=one", "Day one"),
+        ("https://www.youtube.com/watch?v=two", "Day two"),
+        ("not-a-url", "Skipped: no absolute URL"),
+    )
+    job_id = _import(library, session, monkeypatch, url=PLAYLIST_URL, audio_only=True)
+
+    job = _activity(library, job_id)
+    assert job["status"] == "done"
+    assert job["detail"] == "Queued 2 imports"
+    assert job["asset_name"] == "Conference 2017"
+
+    children = _children(session, job_id)
+    assert [c.asset_name for c in children] == ["Day one", "Day two"]
+    for child in children:
+        payload = json.loads(child.payload)
+        assert payload["audio_only"] is True
+        assert payload["depth"] == 1
+        assert child.status == "queued"
+
+
+def test_a_playlist_is_capped(library, session, monkeypatch):
+    from app.config import settings
+
+    monkeypatch.setattr(settings, "url_import_max_playlist_items", 2)
+    FakeYoutubeDL.infos[PLAYLIST_URL] = _playlist(
+        ("https://www.youtube.com/watch?v=one", "One"),
+        ("https://www.youtube.com/watch?v=two", "Two"),
+        playlist_count=40,
+    )
+    job_id = _import(library, session, monkeypatch, url=PLAYLIST_URL)
+
+    assert FakeYoutubeDL.made[0]["playlist_items"] == "1:2"
+    assert _activity(library, job_id)["detail"] == "Queued 2 imports (the first 2 of 40)"
+
+
+@needs_ffmpeg
+def test_a_playlist_skips_what_is_already_imported(library, session, monkeypatch):
+    _import(library, session, monkeypatch)  # VIDEO_URL is now in the library
+    FakeYoutubeDL.infos[PLAYLIST_URL] = _playlist(
+        (VIDEO_URL, "Already here"),
+        ("https://www.youtube.com/watch?v=new", "New"),
+    )
+    job_id = _import(library, session, monkeypatch, url=PLAYLIST_URL)
+
+    assert _activity(library, job_id)["detail"] == "Queued 1 import, 1 already in your library"
+    assert [c.asset_name for c in _children(session, job_id)] == ["New"]
+
+
+@needs_ffmpeg
+def test_a_queued_playlist_entry_imports_like_any_other(library, session, monkeypatch):
+    FakeYoutubeDL.infos[PLAYLIST_URL] = _playlist((VIDEO_URL, "Only video"))
+    parent_id = _import(library, session, monkeypatch, url=PLAYLIST_URL)
+    [child] = _children(session, parent_id)
+
+    _run(session, monkeypatch, child.id)
+    assert _activity(library, child.id)["status"] == "done"
+    assert _only_import(session).source_url == VIDEO_URL
+
+
+def test_playlists_nested_too_deep_are_refused(library, session, monkeypatch):
+    FakeYoutubeDL.infos[PLAYLIST_URL] = _playlist(("https://www.youtube.com/watch?v=x", "x"))
+    job = EnrichmentJob(
+        user_id=TEST_USER,
+        kind=KIND_IMPORT_URL,
+        payload=json.dumps({"url": PLAYLIST_URL, "depth": 2}),
+    )
+    session.add(job)
+    session.commit()
+
+    finished = _run(session, monkeypatch, job.id)
+    assert finished.status == "error"
+    assert "nested too deeply" in finished.error_message
+
+
+def test_an_empty_playlist_is_an_error(library, session, monkeypatch):
+    FakeYoutubeDL.infos[PLAYLIST_URL] = _playlist()
+    job = _activity(library, _import(library, session, monkeypatch, url=PLAYLIST_URL))
+    assert job["status"] == "error"
+    assert "nothing in it" in job["error_message"]
+
+
+# ─── refusals and failures ───────────────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    ("live_status", "fragment"),
+    [("is_live", "live stream"), ("is_upcoming", "not started"), ("post_live", "just ended")],
+)
+def test_live_streams_are_refused(library, session, monkeypatch, live_status, fragment):
+    FakeYoutubeDL.infos[VIDEO_URL] = video_info(live_status=live_status)
+    job = _activity(library, _import(library, session, monkeypatch))
+
+    assert job["status"] == "error"
+    assert fragment in job["error_message"]
+    assert session.exec(select(Asset)).all() == []
+
+
+@pytest.mark.parametrize(
+    ("message", "expected"),
+    [
+        (
+            "ERROR: [youtube] abc123: Sign in to confirm you’re not a bot. Use --cookies-from-browser",
+            "URL_IMPORT_COOKIES_FILE",
+        ),
+        (
+            "ERROR: No suitable extractor found for URL https://example.com/x",
+            "not one yt-dlp knows",
+        ),
+        (
+            "ERROR: [youtube] abc123: Requested format is not available",
+            "yt-dlp needs updating",
+        ),
+        ("ERROR: [youtube] abc123: Private video", "Private video"),
+    ],
+)
+def test_yt_dlp_failures_become_readable_messages(library, session, monkeypatch, message, expected):
+    FakeYoutubeDL.errors[VIDEO_URL] = DownloadError(message)
+    job = _activity(library, _import(library, session, monkeypatch))
+
+    assert job["status"] == "error"
+    assert expected in job["error_message"]
+    assert not job["error_message"].startswith("ERROR")
+
+
+def test_cancelling_mid_download_stops_the_job(library, session, monkeypatch):
+    """The progress hook is the checkpoint: the reporter raises JobCancelled, which the
+    hook turns into the exception yt-dlp is written to let through."""
+
+    def cancelled_reporter(self, job_id):
+        def report(stage, percent, detail=""):
+            if stage.startswith("Downloading"):
+                raise JobCancelled(job_id)
+
+        return report
+
+    monkeypatch.setattr(type(enrichment_jobs.queue()), "reporter", cancelled_reporter)
+    job_id = _import(library, session, monkeypatch)
+
+    assert _activity(library, job_id)["status"] == "cancelled"
+    assert session.exec(select(Asset)).all() == []
+
+
+def test_a_malformed_payload_fails_cleanly(library, session, monkeypatch):
+    job = EnrichmentJob(user_id=TEST_USER, kind=KIND_IMPORT_URL, payload="{not json")
+    session.add(job)
+    session.commit()
+
+    finished = _run(session, monkeypatch, job.id)
+    assert finished.status == "error"
+    assert "no link" in finished.error_message
+
+
+def test_a_child_url_pointing_inward_is_refused_by_the_job(library, session, monkeypatch):
+    """A playlist's entries are URLs the site chose. The job re-checks them rather than
+    trusting that the router saw them — it never did."""
+    job = EnrichmentJob(
+        user_id=TEST_USER,
+        kind=KIND_IMPORT_URL,
+        payload=json.dumps({"url": "https://127.0.0.1/admin", "depth": 1}),
+    )
+    session.add(job)
+    session.commit()
+
+    finished = _run(session, monkeypatch, job.id)
+    assert finished.status == "error"
+    assert "public host" in finished.error_message
+    assert FakeYoutubeDL.made == []
+
+
+# ─── the pure mapping ────────────────────────────────────────────────────────
+
+
+def test_creator_is_only_taken_when_the_site_names_one():
+    meta = ytdlp.metadata_from_info(video_info(creators=["Jane Doe", "John Roe"]))
+    assert meta.attribution["creator"] == "Jane Doe, John Roe"
+
+
+def test_series_is_the_containing_work_when_there_is_one():
+    meta = ytdlp.metadata_from_info(video_info(series="The Long Interview"))
+    assert meta.attribution["source_title"] == "The Long Interview"
+    assert meta.title == "Giordano on neuroweapons"
+
+
+def test_no_license_is_invented():
+    meta = ytdlp.metadata_from_info(video_info(license=None))
+    assert "license" not in meta.attribution
+
+
+def test_release_date_wins_over_upload_date():
+    meta = ytdlp.metadata_from_info(video_info(release_date="20170101"))
+    assert meta.attribution["published_date"] == "2017-01-01"
+
+
+def test_a_bare_release_year_is_kept_as_a_year():
+    meta = ytdlp.metadata_from_info(video_info(upload_date=None, release_year=1994))
+    assert meta.attribution["published_date"] == "1994"
diff --git a/docker-compose.yml b/docker-compose.yml
index 394162d..685458c 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -17,6 +17,9 @@ services:
       - ENVIRONMENT=${ENVIRONMENT:-production}
       - JOB_HEARTBEAT_SECONDS=${JOB_HEARTBEAT_SECONDS:-30}
       - JOB_STALE_MINUTES=${JOB_STALE_MINUTES:-40}
+      - URL_IMPORT_MAX_HEIGHT=${URL_IMPORT_MAX_HEIGHT:-1080}
+      - URL_IMPORT_MAX_PLAYLIST_ITEMS=${URL_IMPORT_MAX_PLAYLIST_ITEMS:-200}
+      - URL_IMPORT_COOKIES_FILE=${URL_IMPORT_COOKIES_FILE:-}
     # Never published to the host: the frontend proxies it, and nothing else should
     # reach it directly — ProxyHeadersMiddleware trusts X-Forwarded-* from any peer.
     expose:
diff --git a/docs/m10-attribution.md b/docs/m10-attribution.md
index e9215ee..144c3c5 100644
--- a/docs/m10-attribution.md
+++ b/docs/m10-attribution.md
@@ -285,8 +285,10 @@ instance of it.
 
 - **No fetching metadata from `source_url`.** OpenGraph/oEmbed lookup against a
   user-supplied URL is an outbound request to an arbitrary host; it needs `safe_url.py`,
-  a job, and a rate-limit story. Worth doing, and it belongs with URL import, which is its
-  own outstanding item.
+  a job, and a rate-limit story. Worth doing, and it belongs with URL import — which has
+  since been built ([`url-import.md`](url-import.md)) and fills attribution for whatever
+  it imports, including `retrieved_at`. Looking up metadata for a file that was
+  *uploaded* with a `source_url` typed beside it is still not done.
 - **No rights-clearance workflow.** `license` records what is known. Whether something may
   be used is a judgement, not a column.
 - **No credits-roll export.** That is GVC's job, and this milestone exists to give it
diff --git a/docs/plan-of-attack.md b/docs/plan-of-attack.md
index f5d6318..67f5b17 100644
--- a/docs/plan-of-attack.md
+++ b/docs/plan-of-attack.md
@@ -349,12 +349,14 @@ Found by auditing the code against this document rather than trusting it. None b
 numbered milestone, and none is deliberate — they are here so a later session can tell a gap
 from a decision, which is the distinction PR bodies do not preserve.
 
-- **URL import (M1) was specified and never built.** No endpoint — though the SSRF guard
-  it needs now exists as `backend/app/safe_url.py`, added for M6's provider base URLs and
-  written to be reusable from here. The tell is `SOURCE_URL` in
-  `ingest/filetypes.py`, declared with no writer — as are `SOURCE_AI` and `SOURCE_GVC`, which
-  are legitimately waiting on M8 and M9. `FilterBar` offers an "AI generated" source filter,
-  wired end to end and tested, over a value nothing can currently set.
+- **~~URL import (M1) was specified and never built.~~** Built, and wider than M1 asked:
+  paste a YouTube link — or one from any of the ~1,800 sites yt-dlp names — and a job
+  downloads it and fills in title, description, attribution, tags, chapter clips and, with
+  no Deepgram key, the captions as transcript. Playlists fan out one job per video.
+  Specified, with its decisions, operating notes and known limitations, in
+  [`url-import.md`](url-import.md). `SOURCE_URL` now has its writer; `SOURCE_AI` and
+  `SOURCE_GVC` are still legitimately waiting on M8 and M9, and `FilterBar`'s "AI
+  generated" filter is still over a value nothing can set.
 - **~~`extract_text` was specified and never built.~~** Built. PDF, `.docx`, `.pptx`,
   `.xlsx`, `.txt`/`.md`/`.csv`, one `DocumentPage` row per natural unit, and a
   `FROM_DOCUMENT` branch in `enrichment/source.py` placed **above** the poster branch —
diff --git a/docs/url-import.md b/docs/url-import.md
new file mode 100644
index 0000000..c0d81cd
--- /dev/null
+++ b/docs/url-import.md
@@ -0,0 +1,146 @@
+# Import from URL
+
+**Status:** built. Closes the M1 gap `plan-of-attack.md` recorded as "URL import was
+specified and never built", and the M10 deferral "no fetching metadata from
+`source_url` — it belongs with URL import".
+
+Paste a link under the drop zone. A background job downloads it with
+[yt-dlp](https://github.com/yt-dlp/yt-dlp), catalogues it through the same pipeline an
+upload takes, and fills in what the site said about it: title, description, channel,
+date, licence, tags, chapters, and — when there is no Deepgram key — its captions as the
+transcript. It shows in the activity indicator like any other job, and lands at the top
+of the library grid when it finishes.
+
+---
+
+## Decisions
+
+Each was put to the user. The reasons are recorded because the code alone does not
+preserve them.
+
+| Question | Decision | Why |
+|---|---|---|
+| Which sites | **Any site yt-dlp names** (~1,800: YouTube, Rumble, Odysee, BitChute, Vimeo, X, podcasts…) — **except its `generic` extractor** | The code is identical either way, and a video mirrored elsewhere after a takedown should still have a way in. `generic` is the fallback that scrapes *any* page for something playable; it is the part a pasted URL could aim at an internal address, and the part most likely to import the wrong thing. |
+| Captions | **Fallback only.** Deepgram when a key is configured; the site's captions when not | Deepgram is diarised, word-timed and punctuated, and the upload chain already queues it. Without a key, a video that stores its captions is searchable by what was said the moment it lands, rather than never. |
+| Uploader tags | **Applied by default**, with a per-import checkbox that routes them to suggestions instead | The user's call. It differs from autotag's rule that nothing is ever applied silently (FR 9.1.4), and deliberately: that rule exists because a model's tags are a guess. An uploader's tags are what they chose to call their own video — closer to embedded metadata than to inference. The checkbox is for channels that pad their tags for search. |
+| Chapters | **One clip per chapter**, per-import checkbox | Chapters are someone else's already-done work of finding the moments. Clips cost no disk. |
+| Playlists | **One job per video** | Each download is long, independently fallible and independently cancellable; a failure on video 30 should cost video 30, not 31–50. |
+| Audio only | Per-import checkbox, `.m4a` | Talks and podcasts where the picture is a static frame, at a tenth of the size. |
+| Quality | **1080p cap**, H.264/AAC preferred, `URL_IMPORT_MAX_HEIGHT` to change | 1080p is the highest YouTube serves as H.264, the codec every browser (Safari included) plays from MP4 without a re-encode. Above it is VP9/AV1. |
+
+## What the site says, and where it goes
+
+| GAM field | From | Notes |
+|---|---|---|
+| `name` | `title` | Also the display filename's stem. |
+| `description` | `description` | Capped at 20,000 characters, the same limit a hand edit has. The Describe button replaces it on request. |
+| `source_url` | `webpage_url` | The canonical address, which is also what de-duplicates. |
+| `publisher` | `channel`, else `uploader` | The channel is the outlet. |
+| `creator` | `creators` / `artists` only | **Never copied from the channel.** On a news or interview channel the channel is rarely the person speaking, and "Creator: BBC News" is the confidently wrong citation M10 exists to prevent. The attribute job can propose the speaker from the transcript, with evidence. |
+| `source_title` | `series`, else `album`, else `title` | `name` is the user's to rename; the citation keeps what the work was published as. |
+| `published_date` | `release_date`, else `upload_date`, else `release_year` | Through `normalise_partial_date`, so a bare year stays a year. |
+| `license` | `license` | Only when stated. YouTube reports Creative Commons and says nothing for its standard licence; nothing is invented. |
+| `retrieved_at` | now | The one attribution field only an import can know — M10 left it with no automatic writer until this. |
+| thumbnail | the site's | The picture people remember the video by, and the only one an audio import gets. |
+| tags | `tags` | Whitespace collapsed, case-insensitive duplicates and anything over 80 characters dropped, 50 at most. |
+| clips | `chapters` | Named "Chapter — Video", clamped to the file's real length; a lone chapter spanning the whole video is skipped. |
+| transcript | captions, VTT | Only without a Deepgram key. Hand-written beats automatic; the video's own language beats YouTube's auto-translations. Recorded as model `youtube-captions` or `youtube-auto-captions`, so it is visible which kind a search is matching. |
+
+Everything from the site is stamped `embedded` in `field_provenance`: a statement of fact
+from the source that no person here has checked — the same standing as an EXIF Artist.
+
+## How it fits together
+
+| File | Role |
+|---|---|
+| `backend/app/routers/imports.py` | `POST /api/assets/import`. Normalises the URL, checks it against `safe_url`, queues the job. Makes no yt-dlp call — reading a page takes seconds. |
+| `backend/app/ingest/ytdlp.py` | The only module that imports `yt_dlp`: the options, the probe, the download, the error rewording, and the pure info-dict → fields mapping. |
+| `backend/app/ingest/captions.py` | VTT → transcript segments, including undoing YouTube's rolling duplicate lines. Pure. |
+| `backend/app/enrichment/import_url.py` | The job body: playlist fan-out, dedup, download, `ingest_file`, then metadata, thumbnail, tags, clips, captions. |
+| `backend/app/services/assets.py::ingest_file` | The sync twin of `ingest_upload`. Both end in the same `_catalogue`, so an import is probed, thumbnailed, indexed and queued for Deepgram by the upload's own code. |
+| `backend/app/enrichment/transcribe.py::store_transcript` | The transcript writer, split out of the Deepgram job so captions and Deepgram store identically. |
+| `frontend/src/components/UrlImport.tsx` | The form under the drop zone. |
+| `frontend/src/views/LibraryView.tsx` | Adds a finished import (and its chapter clips) to the grid, on seeing its job go from running to done. |
+
+`KIND_IMPORT_URL` is a library kind: the asset does not exist when the job is queued. The
+request rides in `EnrichmentJob.payload`, and the finished job adds `created_asset_id`
+there — the same field an M7 "extract" job uses, so `result_asset_id` on the activity row
+works for both. No migration was needed.
+
+Security: the URL is checked twice — by the router, and again by the job, because a
+playlist's entries are URLs the *site* chose and the router never saw them. `generic` is
+excluded from yt-dlp's extractors. Downloads land under fixed filenames (`media.%(ext)s`)
+rather than names built from the title, which is text the site controls.
+
+---
+
+## Operating it
+
+### When imports start failing
+
+YouTube changes under yt-dlp every few weeks, and a pinned yt-dlp eventually stops
+working on its own schedule. The error message says so ("…yt-dlp needs updating"). The
+fix is always the same:
+
+1. Set `yt-dlp[default,deno]==<latest>` in `backend/requirements.txt`
+   ([releases](https://pypi.org/project/yt-dlp/#history)).
+2. `docker compose up --build -d`.
+
+### Deno
+
+Since late 2025 YouTube serves almost no downloadable formats to a client that cannot run
+its JavaScript challenges. yt-dlp solves them with an external runtime: the `deno` extra
+installs Deno from PyPI (manylinux wheels, x86_64 and aarch64, about 40 MB) and the
+`default` extra brings the `yt-dlp-ejs` solver scripts. The backend logs a warning at
+startup if `deno` is not on `PATH`.
+
+### "Sign in to confirm you're not a bot"
+
+YouTube shows this to many datacenter and VPS IP ranges; home connections usually never
+see it. Age-restricted videos need a signed-in session too. Export your browser's
+`youtube.com` cookies in Netscape format (the
+[yt-dlp FAQ](https://github.com/yt-dlp/yt-dlp/wiki/FAQ#how-do-i-pass-cookies-to-yt-dlp)
+covers how, and why a private window is best), mount the file read-only into the backend,
+and point `URL_IMPORT_COOKIES_FILE` at it. yt-dlp is given a *copy*, because it writes the
+jar back out when it finishes. Treat the file like a password: it is a signed-in session.
+
+### Disk
+
+A download goes to a temp directory in the container, then is copied into the media tree
+— the same shape sub-video extraction uses. A long 1080p video needs roughly twice its
+size free while that happens.
+
+### Settings
+
+| Variable | Default | |
+|---|---|---|
+| `URL_IMPORT_MAX_HEIGHT` | `1080` | Tallest video fetched. |
+| `URL_IMPORT_MAX_PLAYLIST_ITEMS` | `200` | Most videos one playlist or channel link may queue. |
+| `URL_IMPORT_COOKIES_FILE` | empty | See above. |
+
+---
+
+## Known limitations
+
+Recorded so a later session can tell a gap from a decision.
+
+- **A video with chapter clips cannot be deleted directly.** M7's delete guard blocks a
+  parent with live clips, so a twenty-chapter import needs its clips removed or promoted
+  first. Untick "Chapters as clips" for anything you may not keep. A "delete with its
+  clips" option is the natural follow-up.
+- **Downloads share the enrichment worker.** With the default `enrichment_concurrency`
+  of 1, a long download holds up transcriptions queued behind it, and a playlist queues
+  its videos one after another.
+- **A long playlist fills the grid on the next load, not live.** The activity feed shows
+  the ten most recent jobs, and the grid adds an import when it sees that import's job
+  finish. In a forty-video playlist most of the jobs are never in those ten, so their
+  videos appear when the library next loads. The activity indicator still counts them.
+- **A restart mid-download starts that download over.** The job is requeued like any
+  other; the partial file was in a temp directory that did not survive.
+- **Real sites are not exercised in CI.** `tests/test_url_import.py` replaces yt-dlp with a
+  fake that writes real fixture media, so everything downstream of the download runs for
+  real, and the options handed to yt-dlp are asserted on. Whether YouTube accepts them
+  on a given day is only answered by importing something.
+- **Terms of service.** Most sites' terms forbid downloading. What to import is the
+  user's call; the importer records full attribution, which is what makes crediting
+  possible later.
diff --git a/frontend/src/api/imports.ts b/frontend/src/api/imports.ts
new file mode 100644
index 0000000..2492dc6
--- /dev/null
+++ b/frontend/src/api/imports.ts
@@ -0,0 +1,34 @@
+import client from '@/api/client'
+import type { ActivityJob } from '@/api/transcripts'
+
+/**
+ * Importing from a link — YouTube and the other sites yt-dlp knows — over
+ * `routers/imports.py`.
+ *
+ * Returns the queued job rather than an asset: reading the page, downloading and
+ * cataloguing all happen in the background, and a playlist becomes many assets. The
+ * finished job names what it made in `result_asset_id`, the same field a sub-video
+ * extraction uses.
+ */
+
+export interface UrlImportRequest {
+  url: string
+  /** Just the soundtrack, as .m4a. */
+  audio_only?: boolean
+  /** On by default. Off sends the uploader's tags to the suggestion queue instead. */
+  apply_tags?: boolean
+  /** One non-destructive clip per chapter, when the video has chapters. */
+  chapters_as_clips?: boolean
+}
+
+interface DataResponse<T> {
+  data: T
+}
+
+export const importsApi = {
+  fromUrl(request: UrlImportRequest): Promise<ActivityJob> {
+    return client
+      .post<DataResponse<ActivityJob>>('/assets/import', request)
+      .then((r) => r.data.data)
+  },
+}
diff --git a/frontend/src/components/ActivityIndicator.test.tsx b/frontend/src/components/ActivityIndicator.test.tsx
index afb0e4e..36b0e6c 100644
--- a/frontend/src/components/ActivityIndicator.test.tsx
+++ b/frontend/src/components/ActivityIndicator.test.tsx
@@ -65,6 +65,18 @@ describe('ActivityIndicator', () => {
     expect(screen.getByText('Your whole library')).toBeInTheDocument()
   })
 
+  it('names an import by what it is fetching', async () => {
+    // Queued before the asset exists, so the row carries the link — then the title.
+    renderWith([
+      job({ action: 'import_url', asset_id: null, asset_name: 'Giordano lecture' }),
+    ])
+
+    await userEvent.click(screen.getByRole('button', { name: /1 job running/i }))
+
+    expect(screen.getByText('Importing')).toBeInTheDocument()
+    expect(screen.getByText('Giordano lecture')).toBeInTheDocument()
+  })
+
   it('keeps a failed job visible with its reason', async () => {
     renderWith([job({ status: 'error', error_message: 'provider says no' })])
 
diff --git a/frontend/src/components/ActivityIndicator.tsx b/frontend/src/components/ActivityIndicator.tsx
index 2810807..afeb29e 100644
--- a/frontend/src/components/ActivityIndicator.tsx
+++ b/frontend/src/components/ActivityIndicator.tsx
@@ -19,6 +19,7 @@ const LABELS: Record<string, string> = {
   summarize: 'Summarizing',
   autotag: 'Suggesting tags',
   extract_text: 'Reading text',
+  import_url: 'Importing',
 }
 
 function subject(job: ActivityJob): string {
diff --git a/frontend/src/components/UrlImport.test.tsx b/frontend/src/components/UrlImport.test.tsx
new file mode 100644
index 0000000..b8dd66a
--- /dev/null
+++ b/frontend/src/components/UrlImport.test.tsx
@@ -0,0 +1,134 @@
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { AxiosError } from 'axios'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import UrlImport from '@/components/UrlImport'
+import { importsApi } from '@/api/imports'
+import { activityApi, type ActivityJob } from '@/api/transcripts'
+import { useActivityStore } from '@/stores/activity'
+
+function queuedJob(overrides: Partial<ActivityJob> = {}): ActivityJob {
+  return {
+    id: 'j1',
+    kind: 'enrichment',
+    action: 'import_url',
+    status: 'queued',
+    stalled: false,
+    stage: 'Queued',
+    progress: 0,
+    detail: '',
+    asset_id: null,
+    asset_name: 'https://youtu.be/abc123',
+    model: '',
+    result_asset_id: null,
+    error_message: null,
+    created_at: '2026-09-28T10:00:00Z',
+    updated_at: '2026-09-28T10:00:00Z',
+    ...overrides,
+  }
+}
+
+function codedError(code: string, message: string) {
+  const error = new AxiosError('failed')
+  // @ts-expect-error - a minimal response is all apiErrorMessage reads
+  error.response = { data: { detail: { code, message } } }
+  return error
+}
+
+afterEach(() => {
+  useActivityStore.getState().reset()
+  vi.restoreAllMocks()
+})
+
+describe('UrlImport', () => {
+  it('cannot be submitted empty', () => {
+    render(<UrlImport />)
+    expect(screen.getByRole('button', { name: 'Import' })).toBeDisabled()
+  })
+
+  it('queues the link with the default options', async () => {
+    const user = userEvent.setup()
+    const fromUrl = vi.spyOn(importsApi, 'fromUrl').mockResolvedValue(queuedJob())
+    vi.spyOn(activityApi, 'list').mockResolvedValue([queuedJob()])
+    render(<UrlImport />)
+
+    await user.type(screen.getByLabelText('Link to import'), '  youtu.be/abc123 ')
+    await user.click(screen.getByRole('button', { name: 'Import' }))
+
+    await waitFor(() => expect(fromUrl).toHaveBeenCalledTimes(1))
+    // Tags applied and chapters clipped unless unticked — the user's defaults.
+    expect(fromUrl.mock.calls[0][0]).toEqual({
+      url: 'youtu.be/abc123',
+      audio_only: false,
+      apply_tags: true,
+      chapters_as_clips: true,
+    })
+  })
+
+  it('carries the options that were changed', async () => {
+    const user = userEvent.setup()
+    const fromUrl = vi.spyOn(importsApi, 'fromUrl').mockResolvedValue(queuedJob())
+    vi.spyOn(activityApi, 'list').mockResolvedValue([])
+    render(<UrlImport />)
+
+    await user.click(screen.getByLabelText('Audio only'))
+    await user.click(screen.getByLabelText(/apply the uploader.s tags/i))
+    await user.click(screen.getByLabelText('Chapters as clips'))
+    await user.type(screen.getByLabelText('Link to import'), 'https://youtu.be/x{Enter}')
+
+    await waitFor(() => expect(fromUrl).toHaveBeenCalledTimes(1))
+    expect(fromUrl.mock.calls[0][0]).toMatchObject({
+      audio_only: true,
+      apply_tags: false,
+      chapters_as_clips: false,
+    })
+  })
+
+  it('confirms, clears the box, and tells the activity feed', async () => {
+    const user = userEvent.setup()
+    vi.spyOn(importsApi, 'fromUrl').mockResolvedValue(queuedJob())
+    const poll = vi.spyOn(activityApi, 'list').mockResolvedValue([queuedJob()])
+    render(<UrlImport />)
+
+    const input = screen.getByLabelText('Link to import')
+    await user.type(input, 'https://youtu.be/abc123')
+    await user.click(screen.getByRole('button', { name: 'Import' }))
+
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Queued “https://youtu.be/abc123”'
+    )
+    expect(input).toHaveValue('')
+    // Straight away, rather than on the idle poll ten seconds later: otherwise the
+    // indicator says nothing is happening right after the user asked for something.
+    await waitFor(() => expect(poll).toHaveBeenCalled())
+  })
+
+  it('keeps the options ticked for the next link', async () => {
+    const user = userEvent.setup()
+    vi.spyOn(importsApi, 'fromUrl').mockResolvedValue(queuedJob())
+    vi.spyOn(activityApi, 'list').mockResolvedValue([])
+    render(<UrlImport />)
+
+    await user.click(screen.getByLabelText('Audio only'))
+    await user.type(screen.getByLabelText('Link to import'), 'https://youtu.be/a{Enter}')
+    await screen.findByRole('status')
+
+    expect(screen.getByLabelText('Audio only')).toBeChecked()
+  })
+
+  it('shows why a link was refused and keeps it for correcting', async () => {
+    const user = userEvent.setup()
+    vi.spyOn(importsApi, 'fromUrl').mockRejectedValue(
+      codedError('ssrf_blocked', 'The address must point to a public host')
+    )
+    render(<UrlImport />)
+
+    const input = screen.getByLabelText('Link to import')
+    await user.type(input, 'https://127.0.0.1/video{Enter}')
+
+    expect(await screen.findByRole('alert')).toHaveTextContent(
+      'The address must point to a public host'
+    )
+    expect(input).toHaveValue('https://127.0.0.1/video')
+  })
+})
diff --git a/frontend/src/components/UrlImport.tsx b/frontend/src/components/UrlImport.tsx
new file mode 100644
index 0000000..253d8ab
--- /dev/null
+++ b/frontend/src/components/UrlImport.tsx
@@ -0,0 +1,130 @@
+import { useState, type FormEvent, type ReactNode } from 'react'
+import { Link2, Loader2 } from 'lucide-react'
+import { apiErrorMessage } from '@/api/client'
+import { importsApi } from '@/api/imports'
+import { useActivityStore } from '@/stores/activity'
+
+/**
+ * Paste a link, get an asset — the other way into the library beside `UploadZone`.
+ *
+ * Owns no progress bar of its own: an import is a background job like any other, so the
+ * activity indicator already shows it, and a playlist that fans out into forty downloads
+ * has nowhere sensible to put forty bars here anyway. What arrives is added to the grid
+ * by `LibraryView` when its job finishes.
+ *
+ * The input is `type="text"` rather than `type="url"`: the browser's url check refuses
+ * `youtu.be/abc` without a scheme, which is how people paste links, and the server
+ * already accepts and normalises it.
+ */
+export default function UrlImport() {
+  const refreshActivity = useActivityStore((s) => s.refresh)
+
+  const [url, setUrl] = useState('')
+  const [audioOnly, setAudioOnly] = useState(false)
+  const [applyTags, setApplyTags] = useState(true)
+  const [chaptersAsClips, setChaptersAsClips] = useState(true)
+  const [submitting, setSubmitting] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [queued, setQueued] = useState<string | null>(null)
+
+  const submit = async (event: FormEvent) => {
+    event.preventDefault()
+    const link = url.trim()
+    if (!link || submitting) return
+
+    setSubmitting(true)
+    setError(null)
+    setQueued(null)
+    try {
+      const job = await importsApi.fromUrl({
+        url: link,
+        audio_only: audioOnly,
+        apply_tags: applyTags,
+        chapters_as_clips: chaptersAsClips,
+      })
+      setQueued(job.asset_name || link)
+      // Cleared so the next paste is not appended to this one. The options stay: someone
+      // importing a run of talks as audio wants the box to stay ticked.
+      setUrl('')
+      void refreshActivity()
+    } catch (err) {
+      setError(apiErrorMessage(err, 'Could not start that import'))
+    } finally {
+      setSubmitting(false)
+    }
+  }
+
+  return (
+    <form
+      onSubmit={(e) => void submit(e)}
+      className="space-y-2 rounded-lg border border-gray-200 px-3 py-2.5 dark:border-gray-700"
+      aria-label="Import from a link"
+    >
+      <div className="flex items-center gap-2">
+        <Link2 className="h-4 w-4 shrink-0 text-gray-400" aria-hidden="true" />
+        <input
+          className="input min-w-0 flex-1"
+          type="text"
+          inputMode="url"
+          autoComplete="off"
+          spellCheck={false}
+          placeholder="Or paste a YouTube link (or Rumble, Odysee, Vimeo…)"
+          aria-label="Link to import"
+          value={url}
+          onChange={(e) => setUrl(e.target.value)}
+        />
+        <button
+          type="submit"
+          className="btn btn-primary px-3 py-1.5 text-xs disabled:cursor-not-allowed disabled:opacity-50"
+          disabled={!url.trim() || submitting}
+        >
+          {submitting ? <Loader2 className="h-3.5 w-3.5 animate-spin" /> : 'Import'}
+        </button>
+      </div>
+
+      <div className="flex flex-wrap gap-x-4 gap-y-1 pl-6 text-xs text-gray-600 dark:text-gray-400">
+        <Option checked={audioOnly} onChange={setAudioOnly}>
+          Audio only
+        </Option>
+        <Option checked={applyTags} onChange={setApplyTags}>
+          Apply the uploader&rsquo;s tags
+        </Option>
+        <Option checked={chaptersAsClips} onChange={setChaptersAsClips}>
+          Chapters as clips
+        </Option>
+      </div>
+
+      {queued && (
+        <p role="status" className="pl-6 text-xs text-green-700 dark:text-green-400">
+          Queued &ldquo;{queued}&rdquo; — follow it under background activity.
+        </p>
+      )}
+      {error && (
+        <p role="alert" className="pl-6 text-xs text-red-600 dark:text-red-400">
+          {error}
+        </p>
+      )}
+    </form>
+  )
+}
+
+function Option({
+  checked,
+  onChange,
+  children,
+}: {
+  checked: boolean
+  onChange: (checked: boolean) => void
+  children: ReactNode
+}) {
+  return (
+    <label className="flex items-center gap-1.5">
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(e) => onChange(e.target.checked)}
+      />
+      {children}
+    </label>
+  )
+}
diff --git a/frontend/src/stores/library.ts b/frontend/src/stores/library.ts
index 1f8335e..82c66db 100644
--- a/frontend/src/stores/library.ts
+++ b/frontend/src/stores/library.ts
@@ -7,6 +7,7 @@ import {
   type ListAssetsParams,
   type UploadRejection,
 } from '@/api/assets'
+import { clipsApi } from '@/api/clips'
 import { tagsApi, type Tag } from '@/api/tags'
 import { useTagStore } from '@/stores/tags'
 import { apiErrorMessage } from '@/api/client'
@@ -80,6 +81,8 @@ interface LibraryState {
    *  changed it — an enrichment job writing a summary, for instance. */
   refreshAsset: (id: string) => Promise<void>
   openById: (id: string) => Promise<Asset>
+  /** Put a finished URL import — and the chapter clips it made — at the top of the grid. */
+  addImported: (id: string) => Promise<void>
   applyTags: (assetIds: string[], add: string[], remove: string[]) => Promise<void>
   dismissRejections: () => void
   reset: () => void
@@ -332,6 +335,32 @@ export const useLibraryStore = create<LibraryState>((set, get) => ({
     return fresh
   },
 
+  async addImported(id) {
+    // Prepended regardless of the active filters, the same as `upload`: this is what the
+    // user just asked for, and it appearing where they are looking is the confirmation.
+    //
+    // Its chapter clips are fetched too. They are assets in their own right and the
+    // server lists them, so leaving them out would make the grid disagree with the next
+    // reload. Newest first, as the server orders them: the clips were cut after the
+    // parent existed, so they sit above it.
+    //
+    // Guarded like `load`: a filter change or a sign-out in the meantime supersedes this,
+    // and the load that follows either includes it or correctly does not.
+    const token = requestToken
+    try {
+      const [asset, children] = await Promise.all([assetsApi.get(id), clipsApi.list(id)])
+      if (token !== requestToken) return
+      const clips = children.filter((c) => c.source === 'clip')
+      set((state) => {
+        const present = new Set(state.assets.map((a) => a.id))
+        const fresh = [...clips, asset].filter((a) => !present.has(a.id))
+        return { assets: [...fresh, ...state.assets], total: state.total + fresh.length }
+      })
+    } catch {
+      /* the next load will pick it up */
+    }
+  },
+
   async refreshAsset(id) {
     // No optimistic step and no error surfaced: this runs after a background job, not
     // after something the user did, so a failure here should leave the panel showing
diff --git a/frontend/src/views/LibraryView.test.tsx b/frontend/src/views/LibraryView.test.tsx
index 7d8dbc6..55533f0 100644
--- a/frontend/src/views/LibraryView.test.tsx
+++ b/frontend/src/views/LibraryView.test.tsx
@@ -1,4 +1,4 @@
-import { render, screen, waitFor, within } from '@testing-library/react'
+import { act, render, screen, waitFor, within } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import {
   afterEach,
@@ -12,9 +12,11 @@ import {
 import LibraryView from '@/views/LibraryView'
 import { assetsApi, type Asset, type AssetPage } from '@/api/assets'
 import { tagsApi, type Tag } from '@/api/tags'
-import { activityApi, transcriptsApi } from '@/api/transcripts'
+import { activityApi, transcriptsApi, type ActivityJob } from '@/api/transcripts'
+import { clipsApi } from '@/api/clips'
 import { enrichmentApi } from '@/api/enrichment'
 import { usageApi } from '@/api/usage'
+import { useActivityStore } from '@/stores/activity'
 import { useLibraryStore } from '@/stores/library'
 import { useTagStore } from '@/stores/tags'
 import { noAttribution } from '@/test-fixtures'
@@ -92,6 +94,9 @@ beforeEach(() => {
   })
   useLibraryStore.getState().reset()
   useTagStore.getState().reset()
+  // Here rather than in afterEach: the view subscribes to this store, and resetting it
+  // while the last test's view is still mounted is a render outside act().
+  useActivityStore.getState().reset()
 })
 
 afterEach(() => {
@@ -306,3 +311,80 @@ describe('LibraryView selection', () => {
     expect(await screen.findByText('1 selected')).toBeInTheDocument()
   })
 })
+
+describe('LibraryView URL imports', () => {
+  function importJob(overrides: Partial<ActivityJob> = {}): ActivityJob {
+    return {
+      id: 'imp1',
+      kind: 'enrichment',
+      action: 'import_url',
+      status: 'processing',
+      stalled: false,
+      stage: 'Downloading video',
+      progress: 40,
+      detail: '',
+      asset_id: null,
+      asset_name: 'A lecture',
+      model: '',
+      result_asset_id: null,
+      error_message: null,
+      created_at: '2026-09-28T10:00:00Z',
+      updated_at: '2026-09-28T10:00:00Z',
+      ...overrides,
+    }
+  }
+
+  it('adds an import, and its chapter clips, when its job finishes', async () => {
+    const imported = { ...makeAsset('new', 'A lecture'), source: 'url' }
+    const chapter = {
+      ...makeAsset('clip1', 'Opening — A lecture'),
+      source: 'clip',
+      parent_asset_id: 'new',
+    }
+    vi.spyOn(assetsApi, 'get').mockResolvedValue(imported)
+    vi.spyOn(clipsApi, 'list').mockResolvedValue([chapter])
+    render(<LibraryView />)
+    await card('First')
+
+    act(() => useActivityStore.setState({ jobs: [importJob()] }))
+    act(() =>
+      useActivityStore.setState({
+        jobs: [importJob({ status: 'done', result_asset_id: 'new' })],
+      })
+    )
+
+    expect(await screen.findByText('A lecture')).toBeInTheDocument()
+    expect(await screen.findByText('Opening — A lecture')).toBeInTheDocument()
+    expect(await screen.findByText('5 assets')).toBeInTheDocument()
+  })
+
+  it('leaves alone imports that had already finished before the library opened', async () => {
+    /**
+     * The activity feed on mount holds imports finished days ago. Treating "done" alone
+     * as the signal would pull every one of them to the top of the grid on each visit.
+     */
+    const get = vi.spyOn(assetsApi, 'get')
+    useActivityStore.setState({
+      jobs: [importJob({ status: 'done', result_asset_id: 'old' })],
+    })
+    render(<LibraryView />)
+    await card('First')
+
+    expect(get).not.toHaveBeenCalled()
+  })
+
+  it('adds nothing for an import that failed', async () => {
+    const get = vi.spyOn(assetsApi, 'get')
+    render(<LibraryView />)
+    await card('First')
+
+    act(() => useActivityStore.setState({ jobs: [importJob()] }))
+    act(() =>
+      useActivityStore.setState({
+        jobs: [importJob({ status: 'error', error_message: 'Private video' })],
+      })
+    )
+
+    expect(get).not.toHaveBeenCalled()
+  })
+})
diff --git a/frontend/src/views/LibraryView.tsx b/frontend/src/views/LibraryView.tsx
index 6983944..d1cac35 100644
--- a/frontend/src/views/LibraryView.tsx
+++ b/frontend/src/views/LibraryView.tsx
@@ -7,6 +7,8 @@ import DetailDock from '@/components/DetailDock'
 import FilterBar from '@/components/FilterBar'
 import SelectionBar from '@/components/SelectionBar'
 import UploadZone from '@/components/UploadZone'
+import UrlImport from '@/components/UrlImport'
+import { isActive, useActivityStore } from '@/stores/activity'
 import { useLibraryStore } from '@/stores/library'
 
 export default function LibraryView() {
@@ -25,6 +27,8 @@ export default function LibraryView() {
   const load = useLibraryStore((s) => s.load)
   const loadMore = useLibraryStore((s) => s.loadMore)
   const dismissRejections = useLibraryStore((s) => s.dismissRejections)
+  const addImported = useLibraryStore((s) => s.addImported)
+  const jobs = useActivityStore((s) => s.jobs)
 
   const [openId, setOpenId] = useState<string | null>(null)
   const [selected, setSelected] = useState<Set<string>>(new Set())
@@ -55,6 +59,24 @@ export default function LibraryView() {
     return () => observer.disconnect()
   }, [loadMore])
 
+  // A URL import finishes in the background, so nothing else would put its asset in
+  // the grid. Keyed on seeing a job go from running to done rather than on "done" alone:
+  // the activity feed on mount already holds imports finished days ago, and prepending
+  // those would shuffle old assets to the top of the library on every visit.
+  const runningImports = useRef<Set<string>>(new Set())
+  useEffect(() => {
+    for (const job of jobs) {
+      if (job.action !== 'import_url') continue
+      if (isActive(job)) {
+        runningImports.current.add(job.id)
+      } else if (runningImports.current.delete(job.id)) {
+        if (job.status === 'done' && job.result_asset_id) {
+          void addImported(job.result_asset_id)
+        }
+      }
+    }
+  }, [jobs, addImported])
+
   // Drop ids that are no longer on screen — a filter change can retire half a
   // selection, and bulk-tagging rows the user can no longer see is not what they asked
   // for.
@@ -142,6 +164,7 @@ export default function LibraryView() {
             stops describing that the moment the panel is open and drag-resizable. */}
         <div className="@container space-y-4 px-4 py-4">
           <UploadZone />
+          <UrlImport />
 
           {rejections.length > 0 && (
             <div className="flex items-start justify-between gap-3 rounded-md border border-amber-300 bg-amber-50 px-3 py-2 text-xs dark:border-amber-800 dark:bg-amber-950/30">
@@ -249,7 +272,7 @@ function EmptyState({ filtering }: { filtering: boolean }) {
       <p className="max-w-sm text-sm text-gray-600 dark:text-gray-400">
         {filtering
           ? 'Try a different search, or clear the filters.'
-          : 'Drop some files above to get started. You can name and describe them later.'}
+          : 'Drop some files or paste a link above to get started. You can name and describe them later.'}
       </p>
     </div>
   )