diff --git a/src/main/java/com/slatto/domain/video/client/YoutubeApiClient.java b/src/main/java/com/slatto/domain/video/client/YoutubeApiClient.java
new file mode 100644
index 00000000..c2b60893
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/client/YoutubeApiClient.java
@@ -0,0 +1,139 @@
+package com.slatto.domain.video.client;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.slatto.global.exception.BaseException;
+import com.slatto.global.response.code.CommonErrorCode;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.client.SimpleClientHttpRequestFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.client.RestClientException;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@Component
+public class YoutubeApiClient {
+
+    private static final String YOUTUBE_API_BASE_URL = "https://www.googleapis.com";
+    private static final List<String> THUMBNAIL_PRIORITIES =
+            List.of("maxres", "standard", "high", "medium", "default");
+
+    private final RestClient restClient;
+    private final String apiKey;
+
+    @Autowired
+    public YoutubeApiClient(
+            RestClient.Builder restClientBuilder,
+            @Value("${youtube.api.key}") String apiKey,
+            @Value("${youtube.api.connect-timeout}") Duration connectTimeout,
+            @Value("${youtube.api.read-timeout}") Duration readTimeout
+    ) {
+        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
+        requestFactory.setConnectTimeout(connectTimeout);
+        requestFactory.setReadTimeout(readTimeout);
+
+        this.restClient = restClientBuilder
+                .baseUrl(YOUTUBE_API_BASE_URL)
+                .requestFactory(requestFactory)
+                .build();
+        this.apiKey = apiKey;
+    }
+
+    YoutubeApiClient(RestClient restClient, String apiKey) {
+        this.restClient = restClient;
+        this.apiKey = apiKey;
+    }
+
+    public Optional<YoutubeVideoInfo> getVideo(String youtubeVideoId) {
+        YoutubeVideosResponse response;
+        try {
+            response = restClient.get()
+                    .uri(uriBuilder -> uriBuilder
+                            .path("/youtube/v3/videos")
+                            .queryParam("part", "snippet,contentDetails,status")
+                            .queryParam("id", youtubeVideoId)
+                            .queryParam("key", apiKey)
+                            .build())
+                    .retrieve()
+                    .body(YoutubeVideosResponse.class);
+        } catch (RestClientException exception) {
+            throw new BaseException(CommonErrorCode.INTERNAL_SERVER_ERROR);
+        }
+
+        if (response == null || response.items() == null || response.items().isEmpty()) {
+            return Optional.empty();
+        }
+
+        YoutubeVideoItem item = response.items().getFirst();
+        String thumbnailUrl = selectThumbnailUrl(item.snippet().thumbnails());
+        int durationSeconds = Math.toIntExact(Duration.parse(item.contentDetails().duration()).getSeconds());
+
+        return Optional.of(new YoutubeVideoInfo(
+                item.snippet().title(),
+                thumbnailUrl,
+                durationSeconds,
+                item.status().embeddable(),
+                item.status().privacyStatus()
+        ));
+    }
+
+    private String selectThumbnailUrl(Map<String, YoutubeThumbnail> thumbnails) {
+        if (thumbnails == null) {
+            return null;
+        }
+
+        return THUMBNAIL_PRIORITIES.stream()
+                .map(thumbnails::get)
+                .filter(thumbnail -> thumbnail != null && thumbnail.url() != null)
+                .map(YoutubeThumbnail::url)
+                .findFirst()
+                .orElse(null);
+    }
+
+    public record YoutubeVideoInfo(
+            String title,
+            String thumbnailUrl,
+            int durationSeconds,
+            boolean embeddable,
+            String privacyStatus
+    ) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeVideosResponse(List<YoutubeVideoItem> items) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeVideoItem(
+            YoutubeSnippet snippet,
+            YoutubeContentDetails contentDetails,
+            YoutubeStatus status
+    ) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeSnippet(
+            String title,
+            Map<String, YoutubeThumbnail> thumbnails
+    ) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeThumbnail(String url) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeContentDetails(String duration) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeStatus(
+            boolean embeddable,
+            String privacyStatus
+    ) {
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/controller/VideoController.java b/src/main/java/com/slatto/domain/video/controller/VideoController.java
new file mode 100644
index 00000000..0afd8e1a
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/controller/VideoController.java
@@ -0,0 +1,99 @@
+package com.slatto.domain.video.controller;
+
+import com.slatto.domain.video.dto.request.VideoRequest.VideoCreateReqDTO;
+import com.slatto.domain.video.dto.request.VideoRequest.VideoUpdateReqDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoCreateResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoDeleteResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoListResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoUpdateResDTO;
+import com.slatto.domain.video.service.VideoService;
+import com.slatto.global.response.ApiResponse;
+import com.slatto.global.response.code.CommonSuccessCode;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.Positive;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PatchMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@Validated
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/v1/projects/{projectId}/videos")
+public class VideoController {
+
+    private final VideoService videoService;
+
+    @PatchMapping("/{videoId}")
+    @Operation(summary = "영상 수정",
+            description = "프로젝트에 등록된 영상의 제목과 메모를 수정합니다.<br>" +
+                    "수정하지 않을 부분은 null로 넣으면 됩니다.")
+    public ApiResponse<VideoUpdateResDTO> updateVideo(
+            @PathVariable @Positive Long projectId,
+            @PathVariable @Positive Long videoId,
+            @Valid @RequestBody VideoUpdateReqDTO request
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.OK,
+                videoService.updateVideo(memberId, projectId, videoId, request)
+        );
+    }
+
+    @DeleteMapping("/{videoId}")
+    @Operation(summary = "영상 삭제", description = "프로젝트에 등록된 영상을 삭제합니다.")
+    public ApiResponse<VideoDeleteResDTO> deleteVideo(
+            @PathVariable @Positive Long projectId,
+            @PathVariable @Positive Long videoId
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.OK,
+                videoService.deleteVideo(memberId, projectId, videoId)
+        );
+    }
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    @Operation(summary = "영상 등록", description = "프로젝트에 새로운 YouTube 영상을 등록합니다.")
+    public ApiResponse<VideoCreateResDTO> createVideo(
+            @PathVariable @Positive Long projectId,
+            @Valid @RequestBody VideoCreateReqDTO request
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.CREATED,
+                videoService.createVideo(memberId, projectId, request)
+        );
+    }
+
+    @GetMapping
+    @Operation(summary = "영상 목록 조회", description = "프로젝트 멤버가 프로젝트에 등록된 영상을 커서 방식으로 조회합니다.")
+    public ApiResponse<VideoListResDTO> getVideos(
+            @PathVariable @Positive Long projectId,
+            @RequestParam(required = false) @Positive Long cursor,
+            @RequestParam(required = false) @Min(1) @Max(100) Integer size
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.OK,
+                videoService.getVideos(memberId, projectId, cursor, size)
+        );
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/controller/YoutubeController.java b/src/main/java/com/slatto/domain/video/controller/YoutubeController.java
new file mode 100644
index 00000000..9bee96be
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/controller/YoutubeController.java
@@ -0,0 +1,35 @@
+package com.slatto.domain.video.controller;
+
+import com.slatto.domain.video.dto.request.VideoRequest.YoutubeValidateReqDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.YoutubeValidateResDTO;
+import com.slatto.domain.video.service.VideoService;
+import com.slatto.global.response.ApiResponse;
+import com.slatto.global.response.code.CommonSuccessCode;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/v1/videos/youtube")
+public class YoutubeController {
+
+    private final VideoService videoService;
+
+    @PostMapping("/validate")
+    @Operation(summary = "YouTube URL 검증", description = "YouTube 영상 정보와 프로젝트 내 중복 등록 여부를 검증합니다.")
+    public ApiResponse<YoutubeValidateResDTO> validateYoutubeUrl(
+            @Valid @RequestBody YoutubeValidateReqDTO request
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.OK,
+                videoService.validateYoutubeUrl(memberId, request)
+        );
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/dto/request/VideoRequest.java b/src/main/java/com/slatto/domain/video/dto/request/VideoRequest.java
new file mode 100644
index 00000000..7b3a3d95
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/dto/request/VideoRequest.java
@@ -0,0 +1,54 @@
+package com.slatto.domain.video.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Positive;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+
+public class VideoRequest {
+
+    @Schema(description = "영상 수정 요청")
+    public record VideoUpdateReqDTO(
+            @Pattern(regexp = "(?s).*\\S.*", message = "영상 제목은 공백일 수 없습니다.")
+            @Size(max = 255, message = "영상 제목은 최대 255자까지 입력할 수 있습니다.")
+            @Schema(example = "수정된 영상 제목", nullable = true)
+            String title,
+
+            @Schema(example = "수정된 영상 메모", nullable = true)
+            String memo
+    ) {
+    }
+
+    @Schema(description = "YouTube URL 검증 요청")
+    public record YoutubeValidateReqDTO(
+            @NotBlank(message = "YouTube URL은 필수입니다.")
+            @Size(max = 500, message = "YouTube URL은 최대 500자까지 입력할 수 있습니다.")
+            @Schema(example = "https://www.youtube.com/watch?v=abc123")
+            String youtubeUrl,
+
+            @NotNull(message = "프로젝트 ID는 필수입니다.")
+            @Positive(message = "프로젝트 ID는 양수여야 합니다.")
+            @Schema(example = "10")
+            Long projectId
+    ) {
+    }
+
+    @Schema(description = "영상 등록 요청")
+    public record VideoCreateReqDTO(
+            @NotBlank(message = "YouTube URL은 필수입니다.")
+            @Size(max = 500, message = "YouTube URL은 최대 500자까지 입력할 수 있습니다.")
+            @Schema(example = "https://www.youtube.com/watch?v=abc123")
+            String youtubeUrl,
+
+            @NotBlank(message = "영상 제목은 필수입니다.")
+            @Size(max = 255, message = "영상 제목은 최대 255자까지 입력할 수 있습니다.")
+            @Schema(example = "프로젝트 명")
+            String title,
+
+            @Schema(example = "영상에 관련된 메모", nullable = true)
+            String memo
+    ) {
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/dto/response/VideoResponse.java b/src/main/java/com/slatto/domain/video/dto/response/VideoResponse.java
new file mode 100644
index 00000000..1f61baab
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/dto/response/VideoResponse.java
@@ -0,0 +1,89 @@
+package com.slatto.domain.video.dto.response;
+
+import com.slatto.domain.video.entity.Video;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public class VideoResponse {
+
+    @Schema(description = "영상 수정 응답")
+    public record VideoUpdateResDTO(
+            @Schema(example = "1") Long videoId,
+            @Schema(example = "수정된 영상 제목") String title,
+            @Schema(example = "수정된 영상 메모", nullable = true) String memo,
+            LocalDateTime updatedAt
+    ) {
+        public static VideoUpdateResDTO from(Video video) {
+            return new VideoUpdateResDTO(
+                    video.getId(), video.getTitle(), video.getMemo(), video.getUpdatedAt()
+            );
+        }
+    }
+
+    @Schema(description = "영상 삭제 응답")
+    public record VideoDeleteResDTO(
+            @Schema(example = "1") Long videoId,
+            @Schema(example = "영상이 삭제되었습니다.") String message
+    ) {
+    }
+
+    @Schema(description = "YouTube URL 검증 응답")
+    public record YoutubeValidateResDTO(
+            @Schema(example = "true") boolean valid,
+            @Schema(example = "abc123") String youtubeVideoId,
+            @Schema(example = "영상 제목") String title,
+            @Schema(example = "https://img.youtube.com/vi/abc123/maxresdefault.jpg") String thumbnailUrl,
+            @Schema(example = "1018") int durationSeconds,
+            @Schema(example = "true") boolean playable,
+            @Schema(example = "등록 가능한 영상입니다.") String message
+    ) {
+    }
+
+    @Schema(description = "영상 등록 응답")
+    public record VideoCreateResDTO(
+            @Schema(example = "1") Long videoId,
+            @Schema(example = "프로젝트 명") String title,
+            @Schema(example = "https://img.youtube.com/vi/abc123/maxresdefault.jpg") String thumbnailUrl,
+            @Schema(example = "1018") Integer durationSeconds,
+            @Schema(example = "false") boolean bookmarked,
+            @Schema(example = "IN_PROGRESS") String progressStatus,
+            LocalDateTime createdAt
+    ) {
+        public static VideoCreateResDTO from(Video video) {
+            return new VideoCreateResDTO(
+                    video.getId(), video.getTitle(), video.getThumbnailUrl(), video.getDurationSeconds(), false,
+                    video.getProgressStatus().name(), video.getCreatedAt()
+            );
+        }
+    }
+
+    @Schema(description = "영상 목록 조회 응답")
+    public record VideoListResDTO(
+            List<VideoItemResDTO> items,
+            @Schema(description = "다음 페이지 조회 커서", example = "9", nullable = true)
+            Long nextCursor,
+            @Schema(description = "다음 목록 존재 여부", example = "true")
+            boolean hasNext
+    ) {
+    }
+
+    public record VideoItemResDTO(
+            @Schema(example = "10") Long videoId,
+            @Schema(example = "프로젝트 명") String title,
+            @Schema(example = "https://img.youtube.com/vi/abc123/maxresdefault.jpg") String thumbnailUrl,
+            @Schema(example = "true") boolean bookmarked,
+            @Schema(example = "IN_PROGRESS") String progressStatus,
+            @Schema(example = "3") int unreadCommentCount,
+            LocalDateTime createdAt,
+            LocalDateTime updatedAt
+    ) {
+        public static VideoItemResDTO from(Video video, boolean bookmarked) {
+            return new VideoItemResDTO(
+                    video.getId(), video.getTitle(), video.getThumbnailUrl(), bookmarked,
+                    video.getProgressStatus().name(), 0, video.getCreatedAt(), video.getUpdatedAt()
+            );
+        }
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/entity/Video.java b/src/main/java/com/slatto/domain/video/entity/Video.java
index 8b71bb73..270f0f4a 100644
--- a/src/main/java/com/slatto/domain/video/entity/Video.java
+++ b/src/main/java/com/slatto/domain/video/entity/Video.java
@@ -2,17 +2,26 @@
 
 import com.slatto.domain.common.entity.BaseEntity;
 import com.slatto.domain.project.entity.Project;
+import com.slatto.domain.video.enums.VideoProgressStatus;
 import jakarta.persistence.*;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 @Entity
-@Table(name = "video")
+@Table(
+        name = "video",
+        uniqueConstraints = @UniqueConstraint(
+                name = "uq_video_project_youtube_video_id",
+                columnNames = {"project_id", "youtube_video_id"}
+        )
+)
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Video extends BaseEntity {
 
+    private static final VideoProgressStatus DEFAULT_PROGRESS_STATUS = VideoProgressStatus.IN_PROGRESS;
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Column(name = "id", nullable = false)
@@ -34,6 +43,53 @@ public class Video extends BaseEntity {
     @Column(name = "thumbnail_url", nullable = true, length = 500)
     private String thumbnailUrl;
 
+    @Column(name = "duration_seconds", nullable = true)
+    private Integer durationSeconds;
+
+    @Enumerated(EnumType.STRING)
     @Column(name = "progress_status", nullable = false, length = 50)
-    private String progressStatus;
-}
\ No newline at end of file
+    private VideoProgressStatus progressStatus;
+
+    @Column(name = "memo", columnDefinition = "TEXT")
+    private String memo;
+
+    private Video(
+            Project project,
+            String youtubeUrl,
+            String youtubeVideoId,
+            String title,
+            String thumbnailUrl,
+            Integer durationSeconds,
+            String memo
+    ) {
+        this.project = project;
+        this.youtubeUrl = youtubeUrl;
+        this.youtubeVideoId = youtubeVideoId;
+        this.title = title;
+        this.thumbnailUrl = thumbnailUrl;
+        this.durationSeconds = durationSeconds;
+        this.progressStatus = DEFAULT_PROGRESS_STATUS;
+        this.memo = memo;
+    }
+
+    public static Video create(
+            Project project,
+            String youtubeUrl,
+            String youtubeVideoId,
+            String title,
+            String thumbnailUrl,
+            Integer durationSeconds,
+            String memo
+    ) {
+        return new Video(project, youtubeUrl, youtubeVideoId, title, thumbnailUrl, durationSeconds, memo);
+    }
+
+    public void updateInfo(String title, String memo) {
+        if (title != null) {
+            this.title = title;
+        }
+        if (memo != null) {
+            this.memo = memo;
+        }
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/enums/VideoProgressStatus.java b/src/main/java/com/slatto/domain/video/enums/VideoProgressStatus.java
new file mode 100644
index 00000000..df6904ce
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/enums/VideoProgressStatus.java
@@ -0,0 +1,6 @@
+package com.slatto.domain.video.enums;
+
+public enum VideoProgressStatus {
+    IN_PROGRESS,
+    DONE
+}
diff --git a/src/main/java/com/slatto/domain/video/repository/VideoBookmarkRepository.java b/src/main/java/com/slatto/domain/video/repository/VideoBookmarkRepository.java
new file mode 100644
index 00000000..9a3053e7
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/repository/VideoBookmarkRepository.java
@@ -0,0 +1,25 @@
+package com.slatto.domain.video.repository;
+
+import jakarta.persistence.EntityManager;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+@RequiredArgsConstructor
+public class VideoBookmarkRepository {
+
+    private final ObjectProvider<EntityManager> entityManagerProvider;
+
+    public List<Long> findBookmarkedVideoIdsByUserIdAndVideoIds(Long userId, List<Long> videoIds) {
+        return entityManagerProvider.getObject().createQuery("""
+                        select bookmark.video.id from VideoBookmark bookmark
+                        where bookmark.user.id = :userId and bookmark.video.id in :videoIds
+                        """, Long.class)
+                .setParameter("userId", userId)
+                .setParameter("videoIds", videoIds)
+                .getResultList();
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/repository/VideoProjectAccessRepository.java b/src/main/java/com/slatto/domain/video/repository/VideoProjectAccessRepository.java
new file mode 100644
index 00000000..05351404
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/repository/VideoProjectAccessRepository.java
@@ -0,0 +1,48 @@
+package com.slatto.domain.video.repository;
+
+import com.slatto.domain.project.entity.Project;
+import jakarta.persistence.EntityManager;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+@RequiredArgsConstructor
+public class VideoProjectAccessRepository {
+
+    private final ObjectProvider<EntityManager> entityManagerProvider;
+
+    public Optional<Project> findProjectById(Long projectId) {
+        return entityManagerProvider.getObject().createQuery("""
+                        select project from Project project
+                        where project.id = :projectId and project.deletedAt is null
+                        """, Project.class)
+                .setParameter("projectId", projectId)
+                .getResultStream()
+                .findFirst();
+    }
+
+    public boolean existsByMemberIdAndProjectId(Long memberId, Long projectId) {
+        return entityManagerProvider.getObject().createQuery("""
+                        select count(member) from ProjectMember member
+                        where member.user.id = :memberId
+                          and member.project.id = :projectId
+                          and member.project.deletedAt is null
+                          and member.leftAt is null
+                        """, Long.class)
+                .setParameter("memberId", memberId)
+                .setParameter("projectId", projectId)
+                .getSingleResult() > 0;
+    }
+
+    public boolean projectExistsById(Long projectId) {
+        return entityManagerProvider.getObject().createQuery("""
+                        select count(project) from Project project
+                        where project.id = :projectId and project.deletedAt is null
+                        """, Long.class)
+                .setParameter("projectId", projectId)
+                .getSingleResult() > 0;
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/repository/VideoRepository.java b/src/main/java/com/slatto/domain/video/repository/VideoRepository.java
new file mode 100644
index 00000000..cb213321
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/repository/VideoRepository.java
@@ -0,0 +1,64 @@
+package com.slatto.domain.video.repository;
+
+import com.slatto.domain.video.entity.Video;
+import jakarta.persistence.EntityManager;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+@RequiredArgsConstructor
+public class VideoRepository {
+
+    private final ObjectProvider<EntityManager> entityManagerProvider;
+
+    public Video save(Video video) {
+        entityManagerProvider.getObject().persist(video);
+        return video;
+    }
+
+    public boolean existsByProjectIdAndYoutubeVideoId(Long projectId, String youtubeVideoId) {
+        return entityManagerProvider.getObject().createQuery("""
+                        select count(video) from Video video
+                        where video.project.id = :projectId
+                          and video.youtubeVideoId = :youtubeVideoId
+                        """, Long.class)
+                .setParameter("projectId", projectId)
+                .setParameter("youtubeVideoId", youtubeVideoId)
+                .getSingleResult() > 0;
+    }
+
+    public Optional<Video> findByIdAndProjectId(Long videoId, Long projectId) {
+        return entityManagerProvider.getObject().createQuery("""
+                        select video from Video video
+                        where video.id = :videoId and video.project.id = :projectId
+                        """, Video.class)
+                .setParameter("videoId", videoId)
+                .setParameter("projectId", projectId)
+                .getResultStream()
+                .findFirst();
+    }
+
+    public void delete(Video video) {
+        entityManagerProvider.getObject().remove(video);
+    }
+
+    public void flush() {
+        entityManagerProvider.getObject().flush();
+    }
+
+    public List<Video> findByProjectIdAndIdLessThanOrderByIdDesc(Long projectId, Long cursor, int limit) {
+        return entityManagerProvider.getObject().createQuery("""
+                        select video from Video video
+                        where video.project.id = :projectId and video.id < :cursor
+                        order by video.id desc
+                        """, Video.class)
+                .setParameter("projectId", projectId)
+                .setParameter("cursor", cursor)
+                .setMaxResults(limit)
+                .getResultList();
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/service/VideoService.java b/src/main/java/com/slatto/domain/video/service/VideoService.java
new file mode 100644
index 00000000..2b333cda
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/service/VideoService.java
@@ -0,0 +1,214 @@
+package com.slatto.domain.video.service;
+
+import com.slatto.domain.project.entity.Project;
+import com.slatto.domain.video.client.YoutubeApiClient;
+import com.slatto.domain.video.client.YoutubeApiClient.YoutubeVideoInfo;
+import com.slatto.domain.video.dto.request.VideoRequest.VideoCreateReqDTO;
+import com.slatto.domain.video.dto.request.VideoRequest.VideoUpdateReqDTO;
+import com.slatto.domain.video.dto.request.VideoRequest.YoutubeValidateReqDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoCreateResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoDeleteResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoItemResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoListResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoUpdateResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.YoutubeValidateResDTO;
+import com.slatto.domain.video.entity.Video;
+import com.slatto.domain.video.repository.VideoBookmarkRepository;
+import com.slatto.domain.video.repository.VideoProjectAccessRepository;
+import com.slatto.domain.video.repository.VideoRepository;
+import com.slatto.domain.video.util.YoutubeUrlParser;
+import com.slatto.global.exception.BaseException;
+import com.slatto.global.response.code.CommonErrorCode;
+import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Set;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class VideoService {
+
+    private static final int DEFAULT_SIZE = 20;
+    private static final int MAX_SIZE = 100;
+    private static final long INITIAL_CURSOR = Long.MAX_VALUE;
+    private static final String THUMBNAIL_URL_FORMAT = "https://img.youtube.com/vi/%s/maxresdefault.jpg";
+    private static final String VALIDATION_SUCCESS_MESSAGE = "등록 가능한 영상입니다.";
+    private static final String PRIVATE_VIDEO_MESSAGE = "비공개 영상은 등록할 수 없습니다.";
+    private static final String NOT_EMBEDDABLE_MESSAGE = "재생할 수 없는 영상은 등록할 수 없습니다.";
+    private static final String VIDEO_DELETED_MESSAGE = "영상이 삭제되었습니다.";
+
+    private final VideoProjectAccessRepository projectAccessRepository;
+    private final VideoRepository videoRepository;
+    private final VideoBookmarkRepository videoBookmarkRepository;
+    private final YoutubeUrlParser youtubeUrlParser;
+    private final YoutubeApiClient youtubeApiClient;
+
+    public YoutubeValidateResDTO validateYoutubeUrl(Long memberId, YoutubeValidateReqDTO request) {
+        if (projectAccessRepository.findProjectById(request.projectId()).isEmpty()) {
+            throw new BaseException(CommonErrorCode.NOT_FOUND);
+        }
+        if (!projectAccessRepository.existsByMemberIdAndProjectId(memberId, request.projectId())) {
+            throw new BaseException(CommonErrorCode.FORBIDDEN);
+        }
+
+        String youtubeVideoId = youtubeUrlParser.extractVideoId(request.youtubeUrl());
+        if (videoRepository.existsByProjectIdAndYoutubeVideoId(request.projectId(), youtubeVideoId)) {
+            throw new BaseException(CommonErrorCode.CONFLICT);
+        }
+
+        YoutubeVideoInfo videoInfo = youtubeApiClient.getVideo(youtubeVideoId)
+                .orElseThrow(() -> new BaseException(CommonErrorCode.NOT_FOUND));
+        boolean valid = !isPrivate(videoInfo.privacyStatus()) && videoInfo.embeddable();
+
+        return new YoutubeValidateResDTO(
+                valid,
+                youtubeVideoId,
+                videoInfo.title(),
+                videoInfo.thumbnailUrl(),
+                videoInfo.durationSeconds(),
+                valid,
+                resolveValidationMessage(videoInfo)
+        );
+    }
+
+    @Transactional
+    public VideoCreateResDTO createVideo(Long memberId, Long projectId, VideoCreateReqDTO request) {
+        Project project = projectAccessRepository.findProjectById(projectId)
+                .orElseThrow(() -> new BaseException(CommonErrorCode.NOT_FOUND));
+        if (!projectAccessRepository.existsByMemberIdAndProjectId(memberId, projectId)) {
+            throw new BaseException(CommonErrorCode.FORBIDDEN);
+        }
+
+        String youtubeVideoId = youtubeUrlParser.extractVideoId(request.youtubeUrl());
+        if (videoRepository.existsByProjectIdAndYoutubeVideoId(projectId, youtubeVideoId)) {
+            throw new BaseException(CommonErrorCode.CONFLICT);
+        }
+
+        YoutubeVideoInfo videoInfo = youtubeApiClient.getVideo(youtubeVideoId)
+                .orElseThrow(() -> new BaseException(CommonErrorCode.NOT_FOUND));
+        if (isPrivate(videoInfo.privacyStatus()) || !videoInfo.embeddable()) {
+            throw new BaseException(CommonErrorCode.BAD_REQUEST);
+        }
+
+        String thumbnailUrl = videoInfo.thumbnailUrl() != null
+                ? videoInfo.thumbnailUrl()
+                : THUMBNAIL_URL_FORMAT.formatted(youtubeVideoId);
+        Video video = Video.create(
+                project,
+                request.youtubeUrl(),
+                youtubeVideoId,
+                request.title(),
+                thumbnailUrl,
+                videoInfo.durationSeconds(),
+                request.memo()
+        );
+
+        try {
+            Video savedVideo = videoRepository.save(video);
+            videoRepository.flush();
+            return VideoCreateResDTO.from(savedVideo);
+        } catch (DataIntegrityViolationException exception) {
+            throw new BaseException(CommonErrorCode.CONFLICT);
+        }
+    }
+
+    public VideoListResDTO getVideos(Long memberId, Long projectId, Long cursor, Integer requestedSize) {
+        if (!projectAccessRepository.projectExistsById(projectId)) {
+            throw new BaseException(CommonErrorCode.NOT_FOUND);
+        }
+        if (!projectAccessRepository.existsByMemberIdAndProjectId(memberId, projectId)) {
+            throw new BaseException(CommonErrorCode.FORBIDDEN);
+        }
+
+        int size = requestedSize == null ? DEFAULT_SIZE : Math.min(requestedSize, MAX_SIZE);
+        long cursorId = cursor == null ? INITIAL_CURSOR : cursor;
+        List<Video> videos = videoRepository.findByProjectIdAndIdLessThanOrderByIdDesc(
+                projectId, cursorId, size + 1
+        );
+        boolean hasNext = videos.size() > size;
+        List<Video> currentPageVideos = videos.stream()
+                .limit(size)
+                .toList();
+        List<Long> videoIds = currentPageVideos.stream()
+                .map(Video::getId)
+                .toList();
+        Set<Long> bookmarkedVideoIds = videoIds.isEmpty()
+                ? Set.of()
+                : Set.copyOf(videoBookmarkRepository.findBookmarkedVideoIdsByUserIdAndVideoIds(memberId, videoIds));
+        List<VideoItemResDTO> items = currentPageVideos.stream()
+                .map(video -> VideoItemResDTO.from(
+                        video,
+                        bookmarkedVideoIds.contains(video.getId())
+                ))
+                .toList();
+        Long nextCursor = hasNext && !items.isEmpty() ? items.getLast().videoId() : null;
+
+        return new VideoListResDTO(items, nextCursor, hasNext);
+    }
+
+    @Transactional
+    public VideoDeleteResDTO deleteVideo(Long memberId, Long projectId, Long videoId) {
+        if (!projectAccessRepository.projectExistsById(projectId)) {
+            throw new BaseException(CommonErrorCode.NOT_FOUND);
+        }
+        if (!projectAccessRepository.existsByMemberIdAndProjectId(memberId, projectId)) {
+            throw new BaseException(CommonErrorCode.FORBIDDEN);
+        }
+
+        Video video = videoRepository.findByIdAndProjectId(videoId, projectId)
+                .orElseThrow(() -> new BaseException(CommonErrorCode.NOT_FOUND));
+        videoRepository.delete(video);
+
+        return new VideoDeleteResDTO(videoId, VIDEO_DELETED_MESSAGE);
+    }
+
+    @Transactional
+    public VideoUpdateResDTO updateVideo(
+            Long memberId,
+            Long projectId,
+            Long videoId,
+            VideoUpdateReqDTO request
+    ) {
+        validateUpdateRequest(request);
+        if (!projectAccessRepository.projectExistsById(projectId)) {
+            throw new BaseException(CommonErrorCode.NOT_FOUND);
+        }
+        if (!projectAccessRepository.existsByMemberIdAndProjectId(memberId, projectId)) {
+            throw new BaseException(CommonErrorCode.FORBIDDEN);
+        }
+
+        Video video = videoRepository.findByIdAndProjectId(videoId, projectId)
+                .orElseThrow(() -> new BaseException(CommonErrorCode.NOT_FOUND));
+        video.updateInfo(request.title(), request.memo());
+        videoRepository.flush();
+
+        return VideoUpdateResDTO.from(video);
+    }
+
+    private void validateUpdateRequest(VideoUpdateReqDTO request) {
+        if (request.title() == null && request.memo() == null) {
+            throw new BaseException(CommonErrorCode.BAD_REQUEST);
+        }
+        if (request.title() != null && request.title().isBlank()) {
+            throw new BaseException(CommonErrorCode.BAD_REQUEST);
+        }
+    }
+
+    private boolean isPrivate(String privacyStatus) {
+        return "private".equals(privacyStatus);
+    }
+
+    private String resolveValidationMessage(YoutubeVideoInfo videoInfo) {
+        if (isPrivate(videoInfo.privacyStatus())) {
+            return PRIVATE_VIDEO_MESSAGE;
+        }
+        if (!videoInfo.embeddable()) {
+            return NOT_EMBEDDABLE_MESSAGE;
+        }
+        return VALIDATION_SUCCESS_MESSAGE;
+    }
+}
diff --git a/src/main/java/com/slatto/domain/video/util/YoutubeUrlParser.java b/src/main/java/com/slatto/domain/video/util/YoutubeUrlParser.java
new file mode 100644
index 00000000..78d07b39
--- /dev/null
+++ b/src/main/java/com/slatto/domain/video/util/YoutubeUrlParser.java
@@ -0,0 +1,89 @@
+package com.slatto.domain.video.util;
+
+import com.slatto.global.exception.BaseException;
+import com.slatto.global.response.code.CommonErrorCode;
+import org.springframework.stereotype.Component;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.regex.Pattern;
+
+@Component
+public class YoutubeUrlParser {
+
+    private static final Pattern VIDEO_ID_PATTERN = Pattern.compile("[A-Za-z0-9_-]{6,100}");
+
+    public String extractVideoId(String youtubeUrl) {
+        try {
+            URI uri = new URI(youtubeUrl.trim());
+            validateScheme(uri);
+
+            String host = uri.getHost();
+            if (host == null) {
+                throwBadRequest();
+            }
+
+            String normalizedHost = host.toLowerCase();
+            if (normalizedHost.equals("youtu.be")) {
+                return requireVideoId(pathSegment(uri, 0));
+            }
+            if (!isYoutubeHost(normalizedHost)) {
+                throwBadRequest();
+            }
+
+            String contentType = pathSegment(uri, 0);
+            if ("shorts".equals(contentType) || "embed".equals(contentType)) {
+                return requireVideoId(pathSegment(uri, 1));
+            }
+
+            if ("/watch".equals(uri.getPath()) && uri.getRawQuery() != null) {
+                for (String parameter : uri.getRawQuery().split("&")) {
+                    String[] keyValue = parameter.split("=", 2);
+                    if (keyValue.length == 2 && "v".equals(keyValue[0])) {
+                        return requireVideoId(keyValue[1]);
+                    }
+                }
+            }
+        } catch (URISyntaxException | IndexOutOfBoundsException exception) {
+            throw new BaseException(CommonErrorCode.BAD_REQUEST);
+        }
+
+        throw new BaseException(CommonErrorCode.BAD_REQUEST);
+    }
+
+    private void validateScheme(URI uri) {
+        if (!"https".equalsIgnoreCase(uri.getScheme())) {
+            throwBadRequest();
+        }
+    }
+
+    private boolean isYoutubeHost(String host) {
+        return host.equals("youtube.com")
+                || host.equals("www.youtube.com")
+                || host.equals("m.youtube.com");
+    }
+
+    private String pathSegment(URI uri, int index) {
+        String path = uri.getRawPath();
+        if (path == null || path.isBlank()) {
+            throwBadRequest();
+        }
+
+        String[] segments = path.substring(1).split("/");
+        if (index >= segments.length) {
+            throwBadRequest();
+        }
+        return segments[index];
+    }
+
+    private String requireVideoId(String videoId) {
+        if (videoId == null || !VIDEO_ID_PATTERN.matcher(videoId).matches()) {
+            throwBadRequest();
+        }
+        return videoId;
+    }
+
+    private void throwBadRequest() {
+        throw new BaseException(CommonErrorCode.BAD_REQUEST);
+    }
+}
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
index 3024aceb..b4eea978 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -23,3 +23,9 @@ springdoc:
     path: /swagger-ui
   api-docs:
     path: /v3/api-docs
+
+youtube:
+  api:
+    key: ${YOUTUBE_API_KEY}
+    connect-timeout: ${YOUTUBE_API_CONNECT_TIMEOUT:3s}
+    read-timeout: ${YOUTUBE_API_READ_TIMEOUT:5s}