diff --git a/composer.json b/composer.json
index 31009f2ce77..12e46b57873 100644
--- a/composer.json
+++ b/composer.json
@@ -24,6 +24,7 @@
         "league/glide": "^3.0 || ^4.0",
         "maennchen/zipstream-php": "^3.1",
         "michelf/php-smartypants": "^1.8.1",
+        "mpratt/embera": "^2.0",
         "nesbot/carbon": "^3.0",
         "pragmarx/google2fa": "^8.0 || ^9.0",
         "rebing/graphql-laravel": "^9.15",
diff --git a/resources/js/components/fieldtypes/VideoFieldtype.vue b/resources/js/components/fieldtypes/VideoFieldtype.vue
index 5282a8b1a3a..5b1ccea384b 100644
--- a/resources/js/components/fieldtypes/VideoFieldtype.vue
+++ b/resources/js/components/fieldtypes/VideoFieldtype.vue
@@ -1,6 +1,26 @@
 <template>
     <div class="flex flex-col space-y-3 p-1.5 bg-gray-100 border border-gray-300 dark:bg-gray-900 dark:border-gray-700 rounded-xl">
-        <ui-input-group>
+        <ui-combobox
+            :model-value="mode"
+            :options="meta.providers"
+            option-label="label"
+            option-value="value"
+            :aria-label="__('Video Provider')"
+            @update:model-value="changeMode"
+        />
+        <ui-input-group v-if="isCloudflare">
+            <ui-input-group-prepend :text="__('ID')" />
+            <ui-input
+                :model-value="videoId"
+                :isReadOnly="isReadOnly"
+                :aria-label="__('Video ID')"
+                @update:model-value="updateCloudflareId"
+                @focus="$emit('focus')"
+                @blur="$emit('blur')"
+                input-class="border-s-0"
+            />
+        </ui-input-group>
+        <ui-input-group v-else>
             <ui-input-group-prepend :text="__('URL')" />
             <ui-input
                 :model-value="value"
@@ -14,8 +34,14 @@
             />
         </ui-input-group>
         <ui-description v-if="isInvalid" class="text-red-600">{{ __('statamic::validation.url') }}</ui-description>
+        <video
+            v-if="shouldShowPreview && isFile"
+            :src="isVisible ? embedUrl : null"
+            controls
+            class="aspect-video rounded-lg w-full"
+        ></video>
         <iframe
-            v-if="shouldShowPreview"
+            v-else-if="shouldShowPreview"
             ref="iframe"
             :src="isVisible ? embedUrl : null"
             frameborder="0"
@@ -27,73 +53,105 @@
 </template>
 
 <script>
+import axios from 'axios';
 import Fieldtype from './Fieldtype.vue';
 
+const CLOUDFLARE = 'cloudflare';
+const CLOUDFLARE_PREFIX = 'cloudflare:';
+const FILE = 'file';
+const UNSUPPORTED = 'unsupported';
+const URL_MODE = 'url';
+
 export default {
     mixins: [Fieldtype],
 
     data() {
         return {
+            abortController: null,
             isVisible: false,
+            lookedUp: this.meta.video,
             observer: null,
+            // Only consulted when there's no value; otherwise the value itself says which input to show.
+            mode: this.meta.video?.provider === CLOUDFLARE ? CLOUDFLARE : URL_MODE,
         };
     },
 
     computed: {
         shouldShowPreview() {
-            return !this.isInvalid && (this.isEmbeddable || this.isVideo);
+            return !this.isInvalid && !!this.embedUrl;
         },
 
-        embedUrl() {
-            let embed_url = this.value || '';
+        isFile() {
+            return this.lookedUp?.url === this.value && this.lookedUp.provider === FILE;
+        },
 
-            if (embed_url.includes('youtube')) {
-                embed_url = embed_url.includes('shorts/')
-                    ? embed_url.replace('shorts/', 'embed/')
-                    : embed_url.replace('watch?v=', 'embed/');
+        embedUrl() {
+            if (this.isCloudflare) {
+                return this.videoId ? `https://iframe.cloudflarestream.com/${this.videoId}` : null;
             }
 
-            if (embed_url.includes('youtu.be')) {
-                embed_url = embed_url.replace('youtu.be', 'www.youtube.com/embed');
-            }
+            return this.lookedUp?.url === this.value ? this.lookedUp.embed_url : null;
+        },
 
-            if (embed_url.includes('vimeo')) {
-                embed_url = embed_url.replace('/vimeo.com', '/player.vimeo.com/video');
+        isCloudflare() {
+            return this.value?.startsWith(CLOUDFLARE_PREFIX) || (!this.value && this.mode === CLOUDFLARE);
+        },
 
-                if (!this.value.includes('progressive_redirect') && embed_url.split('/').length > 5) {
-                    let hash = embed_url.substr(embed_url.lastIndexOf('/') + 1);
-                    embed_url = embed_url.substr(0, embed_url.lastIndexOf('/')) + '?h=' + hash.replace('?', '&');
-                }
-            }
+        isInvalid() {
+            if (this.isCloudflare) return !!this.videoId && !/^[a-zA-Z0-9]+$/.test(this.videoId);
 
-            if (embed_url.includes('&') && !embed_url.includes('?')) {
-                embed_url = embed_url.replace('&', '?');
-            }
+            return !!this.value && this.lookedUp?.url === this.value && this.lookedUp.provider === UNSUPPORTED;
+        },
 
-            return embed_url;
+        videoId() {
+            return this.value?.startsWith(CLOUDFLARE_PREFIX) ? this.value.slice(CLOUDFLARE_PREFIX.length) : null;
         },
+    },
+
+    watch: {
+        value: {
+            handler(value) {
+                if (value?.startsWith(CLOUDFLARE_PREFIX) || !value) return;
 
-        isEmbeddable() {
-            const url = this.value || '';
-            const isYoutube = url.includes('youtube') || url.includes('youtu.be');
-            const isVimeo = url.includes('vimeo');
-            return isYoutube || isVimeo;
+                this.lookup(value);
+            },
+            immediate: true,
         },
+    },
 
-        isInvalid() {
-            let htmlRegex = new RegExp(/<([A-Z][A-Z0-9]*)\b[^>]*>.*?<\/\1>|<([A-Z][A-Z0-9]*)\b[^\/]*\/>/i);
-            return htmlRegex.test(this.value || '');
+    methods: {
+        changeMode(mode) {
+            if (mode === this.mode) return;
+
+            this.mode = mode;
+
+            if (this.value) this.update(null);
         },
 
-        isUrl() {
-            const url = this.value || '';
-            return url.startsWith('http://') || url.startsWith('https://');
+        lookup(value) {
+            if (this.lookedUp?.url === value) return;
+
+            if (this.abortController) this.abortController.abort();
+
+            this.abortController = new AbortController();
+
+            this.$axios
+                .get(this.meta.detailsUrl, { params: { value }, signal: this.abortController.signal })
+                .then((response) => {
+                    // Ignore a response that arrived after the value moved on.
+                    if (value === this.value) this.lookedUp = response.data;
+                })
+                .catch((e) => {
+                    if (axios.isCancel(e)) return;
+                    if (value !== this.value) return;
+
+                    this.lookedUp = null;
+                    this.$toast.error(e.response ? e.response.data.message : __('Something went wrong'));
+                });
         },
 
-        isVideo() {
-            const url = this.value || '';
-            const isVideo = url.includes('.mp4') || url.includes('.ogv') || url.includes('.mov') || url.includes('.webm');
-            return !this.isEmbeddable && isVideo;
+        updateCloudflareId(id) {
+            this.update(id ? `${CLOUDFLARE_PREFIX}${id}` : null);
         },
     },
 
@@ -119,6 +177,10 @@ export default {
         if (this.observer) {
             this.observer.disconnect();
         }
+
+        if (this.abortController) {
+            this.abortController.abort();
+        }
     },
 };
 </script>
diff --git a/resources/js/tests/components/fieldtypes/VideoFieldtype.test.js b/resources/js/tests/components/fieldtypes/VideoFieldtype.test.js
index 241092cdd86..8440442e167 100644
--- a/resources/js/tests/components/fieldtypes/VideoFieldtype.test.js
+++ b/resources/js/tests/components/fieldtypes/VideoFieldtype.test.js
@@ -1,14 +1,24 @@
-import { mount } from '@vue/test-utils';
+import { flushPromises, mount } from '@vue/test-utils';
 import { afterEach, beforeEach, expect, test, vi } from 'vitest';
 import VideoFieldtype from '@/components/fieldtypes/VideoFieldtype.vue';
 import { publishContextKey } from '@/components/ui';
 
 window.__ = (key) => key;
 
+let intersect;
+let axios;
+let toast;
+
 beforeEach(() => {
     vi.useFakeTimers();
 
+    axios = { get: vi.fn().mockResolvedValue({ data: {} }) };
+    toast = { error: vi.fn() };
+
     window.IntersectionObserver = class {
+        constructor(callback) {
+            intersect = () => callback([{ isIntersecting: true, intersectionRatio: 1 }]);
+        }
         observe() {}
         disconnect() {}
     };
@@ -19,23 +29,25 @@ afterEach(() => {
     vi.restoreAllMocks();
 });
 
+const providers = [
+    { value: 'url', label: 'URL' },
+    { value: 'cloudflare', label: 'Cloudflare Stream' },
+];
+
 const stub = (tag) => ({
     props: ['modelValue'],
     emits: ['update:modelValue'],
     template: `<${tag} :value="modelValue" @input="$emit('update:modelValue', $event.target.value)" />`,
 });
 
-const mountVideoField = (props = {}) => {
+const mountVideoField = (value = null, video = null) => {
     return mount(VideoFieldtype, {
-        props: {
-            handle: 'video',
-            config: {},
-            meta: {},
-            ...props,
-        },
+        props: { handle: 'video', config: {}, meta: { providers, video, detailsUrl: '/cp/video/details' }, value },
         global: {
             provide: { [publishContextKey]: {} },
+            mocks: { $axios: axios, $toast: toast },
             stubs: {
+                'ui-combobox': stub('select'),
                 'ui-input': stub('input'),
                 'ui-input-group': { template: '<div><slot /></div>' },
                 'ui-input-group-prepend': { template: '<span />' },
@@ -45,8 +57,68 @@ const mountVideoField = (props = {}) => {
     });
 };
 
+test('it shows the id input for a cloudflare value', () => {
+    const wrapper = mountVideoField('cloudflare:abc123');
+
+    expect(wrapper.find('input').element.value).toBe('abc123');
+});
+
+test('it shows the url input for a url value', () => {
+    const wrapper = mountVideoField('https://vimeo.com/1');
+
+    expect(wrapper.find('input').element.value).toBe('https://vimeo.com/1');
+});
+
+test('it stores the cloudflare id with a prefix', async () => {
+    const wrapper = mountVideoField('cloudflare:old');
+
+    await wrapper.find('input').setValue('abc123');
+
+    expect(wrapper.emitted('update:value')[0]).toEqual(['cloudflare:abc123']);
+});
+
+test('it previews a cloudflare video', async () => {
+    const wrapper = mountVideoField('cloudflare:abc123');
+    intersect();
+    await wrapper.vm.$nextTick();
+
+    expect(wrapper.find('iframe').attributes('src')).toBe('https://iframe.cloudflarestream.com/abc123');
+});
+
+test('it clears the stored value when switching provider', async () => {
+    const wrapper = mountVideoField('https://www.youtube.com/watch?v=1234');
+
+    await wrapper.find('select').setValue('cloudflare');
+
+    expect(wrapper.emitted('update:value')).toHaveLength(1);
+    expect(wrapper.emitted('update:value')[0]).toEqual([null]);
+});
+
+test('it does not emit when switching to the provider already in use', async () => {
+    const wrapper = mountVideoField(null);
+
+    await wrapper.find('select').setValue('url');
+
+    expect(wrapper.emitted('update:value')).toBeUndefined();
+});
+
+test('it rejects a malformed cloudflare id', async () => {
+    const wrapper = mountVideoField('cloudflare:abc"><script>alert(1)</script>');
+    intersect();
+    await wrapper.vm.$nextTick();
+
+    expect(wrapper.find('iframe').exists()).toBe(false);
+    expect(wrapper.find('p').exists()).toBe(true);
+});
+
+test('it uses the provider preloaded in meta for an empty field', () => {
+    const wrapper = mountVideoField(null, { provider: 'cloudflare', url: null });
+
+    expect(wrapper.vm.isCloudflare).toBe(true);
+});
+
 test('it debounces updates while typing', async () => {
-    const wrapper = mountVideoField({ value: null });
+    const wrapper = mountVideoField(null);
     const input = wrapper.find('input');
 
     await input.setValue('https://www.youtube.com/watch?v=1');
@@ -60,3 +132,69 @@ test('it debounces updates while typing', async () => {
     expect(wrapper.emitted('update:value')).toHaveLength(1);
     expect(wrapper.emitted('update:value')[0]).toEqual(['https://www.youtube.com/watch?v=123']);
 });
+
+test('it looks up details for a url value', async () => {
+    axios.get.mockResolvedValue({
+        data: { provider: 'Youtube', url: 'https://www.youtube.com/watch?v=1234', embed_url: 'https://www.youtube.com/embed/1234' },
+    });
+
+    const wrapper = mountVideoField('https://www.youtube.com/watch?v=1234');
+    intersect();
+    await flushPromises();
+
+    expect(axios.get).toHaveBeenCalledWith('/cp/video/details', expect.objectContaining({
+        params: { value: 'https://www.youtube.com/watch?v=1234' },
+    }));
+    expect(wrapper.find('iframe').attributes('src')).toBe('https://www.youtube.com/embed/1234');
+});
+
+test('it does not look up a cloudflare value', async () => {
+    mountVideoField('cloudflare:abc123');
+    await flushPromises();
+
+    expect(axios.get).not.toHaveBeenCalled();
+});
+
+test('it discards a response that resolves after the value moved on', async () => {
+    let resolveStale;
+    axios.get
+        .mockImplementationOnce(() => new Promise((resolve) => (resolveStale = resolve)))
+        .mockResolvedValueOnce({
+            data: { provider: 'Vimeo', url: 'https://vimeo.com/2', embed_url: 'https://player.vimeo.com/video/2' },
+        });
+
+    const wrapper = mountVideoField('https://www.youtube.com/watch?v=1');
+    intersect();
+
+    await wrapper.setProps({ value: 'https://vimeo.com/2' });
+    await flushPromises();
+
+    resolveStale({ data: { provider: 'Youtube', url: 'https://www.youtube.com/watch?v=1', embed_url: 'https://www.youtube.com/embed/1' } });
+    await flushPromises();
+
+    expect(wrapper.find('iframe').attributes('src')).toBe('https://player.vimeo.com/video/2');
+});
+
+test('a failed lookup shows an error', async () => {
+    axios.get.mockRejectedValue({ response: { data: { message: 'Nope' } } });
+
+    const wrapper = mountVideoField('https://www.youtube.com/watch?v=1234');
+    intersect();
+    await flushPromises();
+
+    expect(wrapper.find('iframe').exists()).toBe(false);
+    expect(toast.error).toHaveBeenCalledWith('Nope');
+});
+
+test('it renders a direct video file in a video element', async () => {
+    axios.get.mockResolvedValue({
+        data: { provider: 'file', url: 'https://example.com/clip.mp4', embed_url: 'https://example.com/clip.mp4' },
+    });
+
+    const wrapper = mountVideoField('https://example.com/clip.mp4');
+    intersect();
+    await flushPromises();
+
+    expect(wrapper.find('video').attributes('src')).toBe('https://example.com/clip.mp4');
+    expect(wrapper.find('iframe').exists()).toBe(false);
+});
diff --git a/routes/cp.php b/routes/cp.php
index c0e022faaba..ff2a76e9f2c 100644
--- a/routes/cp.php
+++ b/routes/cp.php
@@ -63,6 +63,7 @@
 use Statamic\Http\Controllers\CP\Fieldtypes\MarkdownFieldtypeController;
 use Statamic\Http\Controllers\CP\Fieldtypes\RelationshipFieldtypeController;
 use Statamic\Http\Controllers\CP\Fieldtypes\ReplicatorSetController;
+use Statamic\Http\Controllers\CP\Fieldtypes\VideoFieldtypeController;
 use Statamic\Http\Controllers\CP\Forms\ActionController as FormActionController;
 use Statamic\Http\Controllers\CP\Forms\FormBlueprintController;
 use Statamic\Http\Controllers\CP\Forms\FormExportController;
@@ -389,6 +390,7 @@
         Route::post('files/upload', [FilesFieldtypeController::class, 'upload'])->name('files.upload');
         Route::post('icons', IconFieldtypeController::class)->name('icon-fieldtype');
         Route::post('replicator/set', ReplicatorSetController::class)->name('replicator-fieldtype.set');
+        Route::get('video/details', [VideoFieldtypeController::class, 'details'])->name('video.details');
     });
 
     Route::group(['prefix' => 'field-action-modal'], function () {
diff --git a/src/Fieldtypes/Video.php b/src/Fieldtypes/Video.php
index 5e12dbf48bf..eeeff8ad319 100644
--- a/src/Fieldtypes/Video.php
+++ b/src/Fieldtypes/Video.php
@@ -3,6 +3,7 @@
 namespace Statamic\Fieldtypes;
 
 use Statamic\Fields\Fieldtype;
+use Statamic\Fieldtypes\Video\Embed;
 
 use function Statamic\trans as __;
 
@@ -10,6 +11,24 @@ class Video extends Fieldtype
 {
     protected $categories = ['media'];
 
+    public function augment($value)
+    {
+        if (is_null($value)) {
+            return null;
+        }
+
+        return Embed::fromValue($value);
+    }
+
+    public function preload()
+    {
+        return [
+            'detailsUrl' => cp_route('video.details'),
+            'providers' => Embed::options(),
+            'video' => Embed::fromValue($this->field()->value())->toArray(),
+        ];
+    }
+
     protected function configFieldItems(): array
     {
         return [
diff --git a/src/Fieldtypes/Video/Embed.php b/src/Fieldtypes/Video/Embed.php
new file mode 100644
index 00000000000..8afec77e193
--- /dev/null
+++ b/src/Fieldtypes/Video/Embed.php
@@ -0,0 +1,300 @@
+<?php
+
+namespace Statamic\Fieldtypes\Video;
+
+use ArrayAccess;
+use Embera\Embera;
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Str;
+use JsonSerializable;
+use Statamic\Contracts\Support\Boolable;
+use Statamic\Support\FileTypes;
+use Throwable;
+
+use function Statamic\trans as __;
+
+class Embed implements Arrayable, ArrayAccess, Boolable, JsonSerializable
+{
+    const CACHE_TTL = 3600;
+    const CLOUDFLARE = 'cloudflare';
+    const CLOUDFLARE_EMBED_URL = 'https://iframe.cloudflarestream.com/';
+    const CLOUDFLARE_ID_PATTERN = '/^[a-zA-Z0-9]+$/';
+    const CLOUDFLARE_PREFIX = 'cloudflare:';
+    const FILE = 'file';
+    const UNSUPPORTED = 'unsupported';
+    const URL = 'url';
+    const VIMEO = 'Vimeo';
+    const YOUTUBE = 'Youtube';
+
+    public static function fromValue(?string $value): self
+    {
+        if (blank($value)) {
+            return static::unsupported($value);
+        }
+
+        if (Str::startsWith($value, self::CLOUDFLARE_PREFIX)) {
+            $id = Str::after($value, self::CLOUDFLARE_PREFIX);
+
+            return preg_match(self::CLOUDFLARE_ID_PATTERN, $id)
+                ? new self(self::CLOUDFLARE, $value, self::CLOUDFLARE_EMBED_URL.$id, $id)
+                : static::unsupported($value);
+        }
+
+        if ($provider = static::knownProvider($value)) {
+            return new self($provider, $value, static::embedUrl($value));
+        }
+
+        if ($video = static::fromOembed($value)) {
+            return $video;
+        }
+
+        if (static::isVideoFile($value)) {
+            return new self(self::FILE, $value, $value);
+        }
+
+        return static::unsupported($value);
+    }
+
+    public static function options(): array
+    {
+        return collect(Providers::names())
+            ->map(fn (string $provider) => ['value' => $provider, 'label' => $provider])
+            ->sortBy('label')
+            ->prepend(['value' => self::URL, 'label' => __('URL')])
+            ->push(['value' => self::CLOUDFLARE, 'label' => __('Cloudflare Stream')])
+            ->values()
+            ->all();
+    }
+
+    public static function unsupported(?string $value = null): self
+    {
+        return new self(self::UNSUPPORTED, $value);
+    }
+
+    public function __construct(
+        public readonly string $provider,
+        public readonly ?string $url = null,
+        public readonly ?string $embedUrl = null,
+        public readonly ?string $id = null,
+    ) {
+    }
+
+    public function isEmbeddable(): bool
+    {
+        return ! in_array($this->provider, [self::FILE, self::UNSUPPORTED]);
+    }
+
+    public function isSupported(): bool
+    {
+        return $this->provider !== self::UNSUPPORTED;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'embed_url' => $this->embedUrl,
+            'id' => $this->id,
+            'provider' => $this->provider,
+            'url' => $this->url,
+        ];
+    }
+
+    public function toBool(): bool
+    {
+        return (bool) $this->url;
+    }
+
+    public function __toString(): string
+    {
+        return (string) $this->url;
+    }
+
+    #[\ReturnTypeWillChange]
+    public function jsonSerialize()
+    {
+        return (string) $this;
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetExists(mixed $offset)
+    {
+        return array_key_exists($offset, $this->toArray());
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetGet(mixed $offset)
+    {
+        return $this->toArray()[$offset] ?? null;
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetSet(mixed $offset, mixed $value)
+    {
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetUnset(mixed $offset)
+    {
+    }
+
+    /**
+     * Turn a link that's direct to a video's page into its embeddable equivalent.
+     */
+    public static function embedUrl(?string $url): ?string
+    {
+        if (blank($url)) {
+            return $url;
+        }
+
+        if (Str::contains($url, 'vimeo')) {
+            return static::vimeoEmbedUrl($url);
+        }
+
+        if (Str::contains($url, 'youtu.be')) {
+            $url = str_replace('youtu.be', 'www.youtube.com/embed', $url);
+
+            // Check for start at point and replace it with correct parameter.
+            if (Str::contains($url, '?t=')) {
+                $url = str_replace('?t=', '?start=', $url);
+            }
+        }
+
+        if (Str::contains($url, 'youtube.com/watch?v=')) {
+            $url = str_replace('watch?v=', 'embed/', $url);
+
+            if (Str::contains($url, '&t=')) {
+                $url = str_replace('&t=', '?start=', $url);
+            }
+        }
+
+        if (Str::contains($url, 'youtube.com/shorts/')) {
+            $url = str_replace('shorts/', 'embed/', $url);
+        }
+
+        if (Str::contains($url, 'youtube.com')) {
+            $url = str_replace('youtube.com', 'youtube-nocookie.com', $url);
+        }
+
+        // This avoids SSL issues when using the non-www version
+        if (Str::contains($url, '//youtube-nocookie.com')) {
+            $url = str_replace('//youtube-nocookie.com', '//www.youtube-nocookie.com', $url);
+        }
+
+        if (Str::contains($url, '&') && ! Str::contains($url, '?')) {
+            $url = Str::replaceFirst('&', '?', $url);
+        }
+
+        return $url;
+    }
+
+    public static function isEmbeddableUrl(?string $url): bool
+    {
+        return filled($url) && Str::contains($url, ['youtu.be', 'youtube', 'vimeo']);
+    }
+
+    protected static function isVideoFile(string $url): bool
+    {
+        if (blank($path = parse_url($url, PHP_URL_PATH))) {
+            return false;
+        }
+
+        return in_array(strtolower(pathinfo($path, PATHINFO_EXTENSION)), FileTypes::video());
+    }
+
+    protected static function knownProvider(string $url): ?string
+    {
+        if (Str::contains($url, 'vimeo')) {
+            return self::VIMEO;
+        }
+
+        if (Str::contains($url, ['youtu.be', 'youtube'])) {
+            return self::YOUTUBE;
+        }
+
+        return null;
+    }
+
+    protected static function fromOembed(string $url): ?self
+    {
+        if ($video = static::lookup($url, Embera::ONLY_FAKE_RESPONSES)) {
+            return $video;
+        }
+
+        return Cache::remember(
+            'statamic::video-fieldtype.'.md5($url),
+            self::CACHE_TTL,
+            fn () => static::lookup($url, Embera::DISABLE_FAKE_RESPONSES),
+        );
+    }
+
+    protected static function lookup(string $url, int $fakeResponses): ?self
+    {
+        try {
+            $response = (new Embera(
+                ['fake_responses' => $fakeResponses],
+                new Providers,
+                new HttpClient,
+            ))->getUrlData($url);
+        } catch (Throwable) {
+            return null;
+        }
+
+        if (empty($response) || blank($embedUrl = static::embedUrlFromHtml($first = Arr::first($response)))) {
+            return null;
+        }
+
+        return new self(Arr::get($first, 'embera_provider_name', self::UNSUPPORTED), $url, $embedUrl);
+    }
+
+    protected static function embedUrlFromHtml(array $response): ?string
+    {
+        if (blank($html = Arr::get($response, 'html'))) {
+            return null;
+        }
+
+        if (! preg_match('/<iframe[^>]+src=["\']([^"\']+)["\']/i', $html, $matches)) {
+            return null;
+        }
+
+        $url = html_entity_decode($matches[1], ENT_QUOTES);
+
+        if (! filter_var($url, FILTER_VALIDATE_URL)) {
+            return null;
+        }
+
+        return match (parse_url($url, PHP_URL_SCHEME)) {
+            'https' => $url,
+            'http' => Str::replaceStart('http://', 'https://', $url),
+            default => null,
+        };
+    }
+
+    // Unlisted vimeo urls are in the form vimeo.com/id/hash, but embeds pass the hash as a get param.
+    protected static function vimeoEmbedUrl(string $url): string
+    {
+        $url = str_replace('/vimeo.com', '/player.vimeo.com/video', $url);
+        $hash = '';
+
+        if (! Str::contains($url, 'progressive_redirect') && Str::substrCount($url, '/') > 4) {
+            $hash = Str::afterLast($url, '/');
+            $url = Str::beforeLast($url, '/');
+
+            if (Str::contains($hash, '?')) {
+                $url .= '?'.Str::after($hash, '?');
+                $hash = Str::before($hash, '?');
+            }
+        }
+
+        $paramsToAdd = '?dnt=1';
+
+        if ($hash) {
+            $paramsToAdd .= '&h='.$hash;
+        }
+
+        return Str::contains($url, '?')
+            ? str_replace('?', $paramsToAdd.'&', $url)
+            : $url.$paramsToAdd;
+    }
+}
diff --git a/src/Fieldtypes/Video/HttpClient.php b/src/Fieldtypes/Video/HttpClient.php
new file mode 100644
index 00000000000..32f44e70027
--- /dev/null
+++ b/src/Fieldtypes/Video/HttpClient.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Statamic\Fieldtypes\Video;
+
+use Embera\Http\HttpClientInterface;
+use Illuminate\Support\Facades\Http;
+use InvalidArgumentException;
+use RuntimeException;
+
+class HttpClient implements HttpClientInterface
+{
+    const CONNECT_TIMEOUT = 5;
+    const TIMEOUT = 10;
+
+    protected array $config = [];
+
+    public function fetch($url, array $params = [])
+    {
+        if (! filter_var($url, FILTER_VALIDATE_URL)) {
+            throw new InvalidArgumentException(sprintf('Invalid url %s', $url));
+        }
+
+        $response = Http::withUserAgent($this->config['user_agent'] ?? 'Statamic')
+            ->connectTimeout(self::CONNECT_TIMEOUT)
+            ->timeout(self::TIMEOUT)
+            ->withOptions(['allow_redirects' => ['max' => 3, 'strict' => true]])
+            ->get($url);
+
+        if ($response->failed()) {
+            throw new RuntimeException(sprintf('Request to %s returned status %s', $url, $response->status()));
+        }
+
+        return $response->body();
+    }
+
+    public function setConfig(array $config = [])
+    {
+        $this->config = $config;
+    }
+}
diff --git a/src/Fieldtypes/Video/Providers.php b/src/Fieldtypes/Video/Providers.php
new file mode 100644
index 00000000000..37975246537
--- /dev/null
+++ b/src/Fieldtypes/Video/Providers.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace Statamic\Fieldtypes\Video;
+
+use Embera\ProviderCollection\ProviderCollectionAdapter;
+
+class Providers extends ProviderCollectionAdapter
+{
+    protected static array $names = [
+        'Bunny',
+        'Coub',
+        'DailyMotion',
+        'Loom',
+        'Rumble',
+        'SproutVideo',
+        'Streamable',
+        'Ted',
+        'TikTok',
+        'Vidyard',
+        'Vimeo',
+        'Wistia',
+        'Youtube',
+    ];
+
+    public function __construct(array $config = [])
+    {
+        parent::__construct($config);
+
+        $this->registerProvider(static::$names);
+    }
+
+    public static function names(): array
+    {
+        return static::$names;
+    }
+}
diff --git a/src/Http/Controllers/CP/Fieldtypes/VideoFieldtypeController.php b/src/Http/Controllers/CP/Fieldtypes/VideoFieldtypeController.php
new file mode 100644
index 00000000000..f8d06a5395a
--- /dev/null
+++ b/src/Http/Controllers/CP/Fieldtypes/VideoFieldtypeController.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Statamic\Http\Controllers\CP\Fieldtypes;
+
+use Illuminate\Http\Request;
+use Statamic\Fieldtypes\Video\Embed;
+use Statamic\Http\Controllers\CP\CpController;
+
+class VideoFieldtypeController extends CpController
+{
+    public function details(Request $request): array
+    {
+        return Embed::fromValue($request->query('value'))->toArray();
+    }
+}
diff --git a/src/Modifiers/CoreModifiers.php b/src/Modifiers/CoreModifiers.php
index 42e3d800704..1f04fcf8df8 100644
--- a/src/Modifiers/CoreModifiers.php
+++ b/src/Modifiers/CoreModifiers.php
@@ -28,6 +28,7 @@
 use Statamic\Fieldtypes\Bard;
 use Statamic\Fieldtypes\Bard\Augmentor;
 use Statamic\Fieldtypes\Link\ArrayableLink;
+use Statamic\Fieldtypes\Video\Embed;
 use Statamic\Statamic;
 use Statamic\Support\Arr;
 use Statamic\Support\Dumper;
@@ -35,6 +36,7 @@
 use Statamic\Support\Str;
 use Statamic\Support\Traits\ChecksDumpability;
 use Statamic\View\Antlers\Language\Runtime\GlobalRuntimeState;
+use Stringable;
 use Stringy\StaticStringy as Stringy;
 
 use function Statamic\trans;
@@ -1560,7 +1562,9 @@ public function length($value)
             return $value->count();
         }
 
-        if ($value instanceof Arrayable) {
+        // Value objects like ArrayableString are both Arrayable and Stringable.
+        // They stand in for a string, so measure the string, not the array.
+        if ($value instanceof Arrayable && ! $value instanceof Stringable) {
             $value = $value->toArray();
         }
 
@@ -3199,60 +3203,11 @@ public function yearsAgo($value, $params)
      */
     public function embedUrl($url)
     {
-        if (Str::contains($url, 'vimeo')) {
-            $url = str_replace('/vimeo.com', '/player.vimeo.com/video', $url);
-
-            [$url, $hash] = $this->handleUnlistedVimeoUrls($url);
-
-            $paramsToAdd = '?dnt=1';
-            if ($hash) {
-                $paramsToAdd .= '&h='.$hash;
-            }
-
-            if (Str::contains($url, '?')) {
-                $url = str_replace('?', $paramsToAdd.'&', $url);
-            } else {
-                $url .= $paramsToAdd;
-            }
-
-            return $url;
-        }
-
-        if (Str::contains($url, 'youtu.be')) {
-            $url = str_replace('youtu.be', 'www.youtube.com/embed', $url);
-
-            // Check for start at point and replace it with correct parameter.
-            if (Str::contains($url, '?t=')) {
-                $url = str_replace('?t=', '?start=', $url);
-            }
-        }
-
-        if (Str::contains($url, 'youtube.com/watch?v=')) {
-            $url = str_replace('watch?v=', 'embed/', $url);
-
-            if (Str::contains($url, '&t=')) {
-                $url = str_replace('&t=', '?start=', $url);
-            }
-        }
-
-        if (Str::contains($url, 'youtube.com/shorts/')) {
-            $url = str_replace('shorts/', 'embed/', $url);
+        if ($url instanceof Embed) {
+            return $url->embedUrl ?? $url->url;
         }
 
-        if (Str::contains($url, 'youtube.com')) {
-            $url = str_replace('youtube.com', 'youtube-nocookie.com', $url);
-        }
-
-        // This avoids SSL issues when using the non-www version
-        if (Str::contains($url, '//youtube-nocookie.com')) {
-            $url = str_replace('//youtube-nocookie.com', '//www.youtube-nocookie.com', $url);
-        }
-
-        if (Str::contains($url, '&') && ! Str::contains($url, '?')) {
-            $url = Str::replaceFirst('&', '?', $url);
-        }
-
-        return $url;
+        return Embed::embedUrl($url);
     }
 
     /**
@@ -3264,6 +3219,14 @@ public function embedUrl($url)
      */
     public function trackableEmbedUrl($url)
     {
+        if ($url instanceof Embed) {
+            $url = $url->url;
+        }
+
+        if (blank($url)) {
+            return $url;
+        }
+
         if (Str::contains($url, 'vimeo')) {
             return str_replace('/vimeo.com', '/player.vimeo.com/video', $url);
         }
@@ -3296,7 +3259,11 @@ public function trackableEmbedUrl($url)
      */
     public function isEmbeddable($url)
     {
-        return Str::contains($url, ['youtu.be', 'youtube', 'vimeo']);
+        if ($url instanceof Embed) {
+            return $url->isEmbeddable();
+        }
+
+        return Embed::isEmbeddableUrl($url);
     }
 
     /**
@@ -3381,24 +3348,6 @@ private function getFromContext($context, $params, $key = 0)
                 Arr::get($context, $params[$key], $params[$key]);
     }
 
-    // unlisted vimeo urls are in the form vimeo.com/id/hash, but embeds pass the hash as a get param
-    private function handleUnlistedVimeoUrls($url)
-    {
-        $hash = '';
-
-        if (! Str::contains($url, 'progressive_redirect') && Str::substrCount($url, '/') > 4) {
-            $hash = Str::afterLast($url, '/');
-            $url = Str::beforeLast($url, '/');
-
-            if (Str::contains($hash, '?')) {
-                $url .= '?'.Str::after($hash, '?');
-                $hash = Str::before($hash, '?');
-            }
-        }
-
-        return [$url, $hash];
-    }
-
     private function dumpingAllowed(array $params): bool
     {
         return $this->traitDumpingAllowed() || (Arr::get($params, 0) === 'force');
diff --git a/tests/CP/Controllers/Fieldtypes/VideoFieldtypeControllerTest.php b/tests/CP/Controllers/Fieldtypes/VideoFieldtypeControllerTest.php
new file mode 100644
index 00000000000..84240594842
--- /dev/null
+++ b/tests/CP/Controllers/Fieldtypes/VideoFieldtypeControllerTest.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace Tests\CP\Controllers\Fieldtypes;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Facades\User;
+use Tests\PreventSavingStacheItemsToDisk;
+use Tests\TestCase;
+
+class VideoFieldtypeControllerTest extends TestCase
+{
+    use PreventSavingStacheItemsToDisk;
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_gets_video_details(array $queryParams, array $video)
+    {
+        $user = tap(User::make()->makeSuper())->save();
+
+        $this
+            ->actingAs($user)
+            ->get(cp_route('video.details', $queryParams))
+            ->assertOK()
+            ->assertExactJson($video);
+    }
+
+    public static function valuesProvider()
+    {
+        return [
+            'no value' => [[], ['embed_url' => null, 'id' => null, 'provider' => 'unsupported', 'url' => null]],
+            'youtube' => [['value' => 'https://www.youtube.com/watch?v=FK3dav4bA4s'], [
+                'embed_url' => 'https://www.youtube-nocookie.com/embed/FK3dav4bA4s',
+                'id' => null,
+                'provider' => 'Youtube',
+                'url' => 'https://www.youtube.com/watch?v=FK3dav4bA4s',
+            ]],
+            'cloudflare' => [['value' => 'cloudflare:1234'], [
+                'embed_url' => 'https://iframe.cloudflarestream.com/1234',
+                'id' => '1234',
+                'provider' => 'cloudflare',
+                'url' => 'cloudflare:1234',
+            ]],
+        ];
+    }
+
+    #[Test]
+    public function it_requires_authentication()
+    {
+        $this
+            ->get(cp_route('video.details', ['value' => 'https://www.youtube.com/watch?v=FK3dav4bA4s']))
+            ->assertRedirect(cp_route('login'));
+    }
+}
diff --git a/tests/Fieldtypes/Video/EmbedTest.php b/tests/Fieldtypes/Video/EmbedTest.php
new file mode 100644
index 00000000000..6346c10f36e
--- /dev/null
+++ b/tests/Fieldtypes/Video/EmbedTest.php
@@ -0,0 +1,157 @@
+<?php
+
+namespace Tests\Fieldtypes\Video;
+
+use Illuminate\Support\Facades\Http;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Fieldtypes\Video\Embed;
+use Tests\TestCase;
+
+class EmbedTest extends TestCase
+{
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_creates_a_video($value, $provider, $id, $embedUrl)
+    {
+        $video = Embed::fromValue($value);
+
+        $this->assertSame($provider, $video->provider);
+        $this->assertSame($id, $video->id);
+        $this->assertSame($embedUrl, $video->embedUrl);
+    }
+
+    public static function valuesProvider()
+    {
+        return [
+            'youtube' => ['https://www.youtube.com/watch?v=FK3dav4bA4s', 'Youtube', null, 'https://www.youtube-nocookie.com/embed/FK3dav4bA4s'],
+            'youtube shorts' => ['https://www.youtube.com/shorts/FK3dav4bA4s', 'Youtube', null, 'https://www.youtube-nocookie.com/embed/FK3dav4bA4s'],
+            'youtu.be' => ['https://youtu.be/FK3dav4bA4s', 'Youtube', null, 'https://www.youtube-nocookie.com/embed/FK3dav4bA4s'],
+            'vimeo' => ['https://vimeo.com/22439234', 'Vimeo', null, 'https://player.vimeo.com/video/22439234?dnt=1'],
+            'cloudflare' => ['cloudflare:1234', 'cloudflare', '1234', 'https://iframe.cloudflarestream.com/1234'],
+            'cloudflare without an id' => ['cloudflare:', 'unsupported', null, null],
+            'cloudflare with a malformed id' => ['cloudflare:1234"></iframe><script>alert(1)</script>', 'unsupported', null, null],
+            'cloudflare with a path traversal id' => ['cloudflare:../../evil', 'unsupported', null, null],
+            'mp4 file' => ['https://example.com/clip.mp4', 'file', null, 'https://example.com/clip.mp4'],
+            'uppercase file extension' => ['https://example.com/clip.MOV', 'file', null, 'https://example.com/clip.MOV'],
+            'file with a query string' => ['https://example.com/clip.webm?t=1', 'file', null, 'https://example.com/clip.webm?t=1'],
+            'unsupported' => ['https://example.com/nope', 'unsupported', null, null],
+            'empty' => ['', 'unsupported', null, null],
+            'null' => [null, 'unsupported', null, null],
+        ];
+    }
+
+    #[Test]
+    public function it_does_not_make_http_requests_for_offline_providers()
+    {
+        Http::preventStrayRequests();
+
+        $this->assertSame('Youtube', Embed::fromValue('https://www.youtube.com/watch?v=FK3dav4bA4s')->provider);
+        $this->assertSame('Vimeo', Embed::fromValue('https://vimeo.com/22439234')->provider);
+    }
+
+    #[Test]
+    public function it_returns_an_embed_url_rather_than_provider_supplied_markup()
+    {
+        Http::fake(['*' => Http::response([
+            'html' => '<img src=x onerror="alert(1)"><iframe src="https://fast.wistia.net/embed/iframe/abc"></iframe>',
+        ])]);
+
+        $video = Embed::fromValue('https://wistia.com/medias/abc');
+
+        $this->assertSame('https://fast.wistia.net/embed/iframe/abc', $video->embedUrl);
+        $this->assertStringNotContainsString('onerror', $video->embedUrl);
+    }
+
+    #[Test]
+    public function it_rejects_an_embed_that_is_not_a_valid_url()
+    {
+        Http::fake(['*' => Http::response(['html' => '<iframe src="javascript:alert(1)"></iframe>'])]);
+
+        $this->assertFalse(Embed::fromValue('https://wistia.com/medias/abc')->isSupported());
+    }
+
+    #[Test]
+    public function it_upgrades_an_insecure_embed_url_to_https()
+    {
+        Http::fake(['*' => Http::response(['html' => '<iframe src="http://fast.wistia.net/embed/iframe/abc"></iframe>'])]);
+
+        $this->assertSame(
+            'https://fast.wistia.net/embed/iframe/abc',
+            Embed::fromValue('https://wistia.com/medias/abc')->embedUrl,
+        );
+    }
+
+    #[Test]
+    public function it_is_not_supported_when_the_lookup_fails()
+    {
+        Http::fake(['*' => Http::response(status: 500)]);
+
+        $this->assertFalse(Embed::fromValue('https://wistia.com/medias/abc')->isSupported());
+    }
+
+    #[Test]
+    public function it_caches_lookups_that_require_a_request()
+    {
+        Http::fake(['*' => Http::response(['html' => '<iframe src="https://fast.wistia.net/embed/iframe/abc"></iframe>'])]);
+
+        Embed::fromValue('https://wistia.com/medias/abc');
+        Embed::fromValue('https://wistia.com/medias/abc');
+
+        Http::assertSentCount(1);
+    }
+
+    #[Test]
+    public function it_casts_to_the_original_value()
+    {
+        $this->assertSame('https://vimeo.com/22439234', (string) Embed::fromValue('https://vimeo.com/22439234'));
+        $this->assertSame('cloudflare:1234', (string) Embed::fromValue('cloudflare:1234'));
+        $this->assertSame('', (string) Embed::fromValue(null));
+    }
+
+    #[Test]
+    public function it_is_truthy_whenever_it_holds_a_value()
+    {
+        $this->assertTrue(Embed::fromValue('https://vimeo.com/22439234')->toBool());
+        $this->assertTrue(Embed::fromValue('https://example.com/nope')->toBool());
+        $this->assertFalse(Embed::fromValue('')->toBool());
+    }
+
+    #[Test]
+    public function it_knows_whether_it_is_supported_and_embeddable()
+    {
+        $this->assertTrue(Embed::fromValue('https://vimeo.com/22439234')->isEmbeddable());
+        $this->assertTrue(Embed::fromValue('https://vimeo.com/22439234')->isSupported());
+
+        // A file is something we can play, but not something we can put in an iframe.
+        $this->assertFalse(Embed::fromValue('https://example.com/clip.mp4')->isEmbeddable());
+        $this->assertTrue(Embed::fromValue('https://example.com/clip.mp4')->isSupported());
+
+        $this->assertFalse(Embed::fromValue('https://example.com/nope')->isEmbeddable());
+        $this->assertFalse(Embed::fromValue('https://example.com/nope')->isSupported());
+    }
+
+    #[Test]
+    public function it_is_arrayable_and_accessible_as_an_array()
+    {
+        $video = Embed::fromValue('cloudflare:1234');
+
+        $this->assertSame([
+            'embed_url' => 'https://iframe.cloudflarestream.com/1234',
+            'id' => '1234',
+            'provider' => 'cloudflare',
+            'url' => 'cloudflare:1234',
+        ], $video->toArray());
+
+        $this->assertSame('https://iframe.cloudflarestream.com/1234', $video['embed_url']);
+        $this->assertTrue(isset($video['provider']));
+        $this->assertNull($video['nope']);
+    }
+
+    #[Test]
+    public function it_serializes_to_json_as_the_original_value()
+    {
+        $this->assertSame('"cloudflare:1234"', json_encode(Embed::fromValue('cloudflare:1234')));
+        $this->assertSame('"https:\\/\\/vimeo.com\\/1"', json_encode(Embed::fromValue('https://vimeo.com/1')));
+    }
+}
diff --git a/tests/Fieldtypes/Video/ParityTest.php b/tests/Fieldtypes/Video/ParityTest.php
new file mode 100644
index 00000000000..e0de27ac11a
--- /dev/null
+++ b/tests/Fieldtypes/Video/ParityTest.php
@@ -0,0 +1,103 @@
+<?php
+
+namespace Tests\Fieldtypes\Video;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Fields\Field;
+use Statamic\Fields\Value;
+use Statamic\Fieldtypes\Video;
+use Statamic\Modifiers\Modify;
+use Tests\TestCase;
+
+/**
+ * An augmented video field has to behave like the string it was before it was
+ * augmented. Everything here would pass against a raw string, so each case
+ * asserts the augmented value agrees with it.
+ *
+ * Cloudflare values are deliberately absent: `cloudflare:<id>` is a new format
+ * with no prior behaviour to preserve. VideoTest covers it instead.
+ */
+class ParityTest extends TestCase
+{
+    public static function valuesProvider()
+    {
+        return [
+            'null' => [null],
+            'empty' => [''],
+            'unsupported' => ['https://example.com/nope'],
+            'youtube' => ['https://www.youtube.com/watch?v=FK3dav4bA4s'],
+            'youtube shorts' => ['https://www.youtube.com/shorts/FK3dav4bA4s'],
+            'youtu.be' => ['https://youtu.be/FK3dav4bA4s'],
+            'vimeo' => ['https://vimeo.com/22439234'],
+            'unlisted vimeo' => ['https://vimeo.com/22439234/abcdef'],
+            'vimeo progressive file' => ['https://player.vimeo.com/progressive_redirect/playback/123/rendition/1080p/file.mp4?loc=external'],
+            'video file' => ['https://example.com/clip.mp4'],
+        ];
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function the_embed_url_modifier_matches_the_raw_value($value)
+    {
+        $this->assertSame(
+            Modify::value($value)->embedUrl()->fetch(),
+            Modify::value($this->augment($value))->embedUrl()->fetch(),
+        );
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function the_trackable_embed_url_modifier_matches_the_raw_value($value)
+    {
+        $this->assertSame(
+            Modify::value($value)->trackableEmbedUrl()->fetch(),
+            Modify::value($this->augment($value))->trackableEmbedUrl()->fetch(),
+        );
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function the_is_embeddable_modifier_matches_the_raw_value($value)
+    {
+        $this->assertSame(
+            Modify::value($value)->isEmbeddable()->fetch(),
+            Modify::value($this->augment($value))->isEmbeddable()->fetch(),
+        );
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_casts_to_the_original_value($value)
+    {
+        $this->assertSame((string) $value, (string) $this->augment($value));
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_is_as_truthy_as_the_original_value($value)
+    {
+        // A null value isn't augmented at all, so there's no object to ask.
+        if (is_null($augmented = $this->augment($value))) {
+            $this->assertNull($value);
+
+            return;
+        }
+
+        $this->assertSame((bool) $value, $augmented->toBool());
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_serializes_to_the_original_value($value)
+    {
+        $field = (new Video)->setField(new Field('test', ['type' => 'video']));
+
+        $this->assertSame(json_encode($value), json_encode(new Value($value, 'test', $field)));
+    }
+
+    private function augment($value)
+    {
+        return (new Video)->setField(new Field('test', ['type' => 'video']))->augment($value);
+    }
+}
diff --git a/tests/Fieldtypes/VideoTest.php b/tests/Fieldtypes/VideoTest.php
new file mode 100644
index 00000000000..fa48ee2c220
--- /dev/null
+++ b/tests/Fieldtypes/VideoTest.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace Tests\Fieldtypes;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Fields\Field;
+use Statamic\Fieldtypes\Video;
+use Statamic\Fieldtypes\Video\Embed;
+use Tests\TestCase;
+
+class VideoTest extends TestCase
+{
+    #[Test]
+    public function it_augments_null_to_null()
+    {
+        $this->assertNull($this->fieldtype()->augment(null));
+    }
+
+    #[Test]
+    #[DataProvider('augmentProvider')]
+    public function it_augments_to_a_video($value, $provider, $id, $embedUrl)
+    {
+        $video = $this->fieldtype()->augment($value);
+
+        $this->assertInstanceOf(Embed::class, $video);
+        $this->assertSame($provider, $video->provider);
+        $this->assertSame($id, $video->id);
+        $this->assertSame($embedUrl, $video->embedUrl);
+    }
+
+    public static function augmentProvider()
+    {
+        return [
+            'url' => ['https://vimeo.com/22439234', 'Vimeo', null, 'https://player.vimeo.com/video/22439234?dnt=1'],
+            'cloudflare' => ['cloudflare:1234', 'cloudflare', '1234', 'https://iframe.cloudflarestream.com/1234'],
+            'file' => ['https://example.com/clip.mp4', 'file', null, 'https://example.com/clip.mp4'],
+            'unsupported' => ['https://example.com/nope', 'unsupported', null, null],
+        ];
+    }
+
+    #[Test]
+    public function the_augmented_value_casts_to_the_original_value_for_backwards_compatibility()
+    {
+        $this->assertSame(
+            'https://vimeo.com/22439234',
+            (string) $this->fieldtype()->augment('https://vimeo.com/22439234'),
+        );
+    }
+
+    #[Test]
+    public function it_preloads_the_providers_and_the_current_video()
+    {
+        $meta = $this->fieldtype('cloudflare:1234')->preload();
+
+        $this->assertSame(['value' => 'url', 'label' => 'URL'], $meta['providers'][0]);
+        $this->assertContains(['value' => 'Youtube', 'label' => 'Youtube'], $meta['providers']);
+        $this->assertContains(['value' => 'cloudflare', 'label' => 'Cloudflare Stream'], $meta['providers']);
+
+        $this->assertSame('cloudflare', $meta['video']['provider']);
+        $this->assertSame('https://iframe.cloudflarestream.com/1234', $meta['video']['embed_url']);
+    }
+
+    #[Test]
+    public function it_preloads_an_empty_field()
+    {
+        $this->assertSame('unsupported', $this->fieldtype()->preload()['video']['provider']);
+    }
+
+    private function fieldtype($value = null)
+    {
+        return tap(new Video, fn (Video $fieldtype) => $fieldtype
+            ->setField(new Field('test', ['type' => 'video']))
+            ->field()->setValue($value)
+        );
+    }
+}
diff --git a/tests/Modifiers/EmbedUrlTest.php b/tests/Modifiers/EmbedUrlTest.php
index 6061c170f3f..645add32196 100644
--- a/tests/Modifiers/EmbedUrlTest.php
+++ b/tests/Modifiers/EmbedUrlTest.php
@@ -3,6 +3,7 @@
 namespace Tests\Modifiers;
 
 use PHPUnit\Framework\Attributes\Test;
+use Statamic\Fieldtypes\Video\Embed;
 use Statamic\Modifiers\Modify;
 use Tests\TestCase;
 
@@ -113,6 +114,20 @@ public function it_ensures_url_with_query_parameters_are_valid()
         );
     }
 
+    #[Test]
+    public function it_gets_the_embed_url_from_an_augmented_video_value()
+    {
+        $this->assertEquals(
+            'https://iframe.cloudflarestream.com/1234',
+            $this->embed(Embed::fromValue('cloudflare:1234')),
+        );
+
+        $this->assertEquals(
+            'https://player.vimeo.com/video/22439234?dnt=1',
+            $this->embed(Embed::fromValue('https://vimeo.com/22439234')),
+        );
+    }
+
     public function embed($url)
     {
         return Modify::value($url)->embedUrl()->fetch();
diff --git a/tests/Modifiers/LengthTest.php b/tests/Modifiers/LengthTest.php
index 826d7168dc6..117c39c43fe 100644
--- a/tests/Modifiers/LengthTest.php
+++ b/tests/Modifiers/LengthTest.php
@@ -6,6 +6,7 @@
 use Mockery;
 use PHPUnit\Framework\Attributes\Test;
 use Statamic\Contracts\Query\Builder;
+use Statamic\Fields\ArrayableString;
 use Statamic\Modifiers\Modify;
 use Tests\TestCase;
 
@@ -47,12 +48,26 @@ public function it_returns_the_number_of_items_in_a_query()
     #[Test]
     public function it_returns_the_number_of_items_in_an_arrayable()
     {
-        $arrayable = Mockery::mock(Arrayable::class)->shouldReceive('toArray')->andReturn(['one', 'two'])->getMock();
+        $arrayable = new class implements Arrayable
+        {
+            public function toArray()
+            {
+                return ['one', 'two'];
+            }
+        };
 
         $modified = $this->modify($arrayable);
         $this->assertSame(2, $modified);
     }
 
+    #[Test]
+    public function it_returns_the_number_of_chars_in_a_stringable_arrayable()
+    {
+        // Value objects like ArrayableString stand in for a string, so the
+        // string is what should get measured, not their array form.
+        $this->assertSame(19, $this->modify(new ArrayableString('https://vimeo.com/1')));
+    }
+
     #[Test]
     public function it_returns_the_numbers_of_chars_in_string(): void
     {