diff --git a/.codeguide/loopers-1-week.md b/.codeguide/loopers-1-week.md
deleted file mode 100644
index a8ace53e..00000000
--- a/.codeguide/loopers-1-week.md
+++ /dev/null
@@ -1,45 +0,0 @@
-## 🧪 Implementation Quest
-
-> 지정된 **단위 테스트 / 통합 테스트 / E2E 테스트 케이스**를 필수로 구현하고, 모든 테스트를 통과시키는 것을 목표로 합니다.
-
-### 회원 가입
-
-**🧱 단위 테스트**
-
-- [ ]  ID 가 `영문 및 숫자 10자 이내` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-- [ ]  이메일이 `xx@yy.zz` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-- [ ]  생년월일이 `yyyy-MM-dd` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-
-**🔗 통합 테스트**
-
-- [ ]  회원 가입시 User 저장이 수행된다. ( spy 검증 )
-- [ ]  이미 가입된 ID 로 회원가입 시도 시, 실패한다.
-
-**🌐 E2E 테스트**
-
-- [ ]  회원 가입이 성공할 경우, 생성된 유저 정보를 응답으로 반환한다.
-- [ ]  회원 가입 시에 성별이 없을 경우, `400 Bad Request` 응답을 반환한다.
-
-### 내 정보 조회
-
-**🔗 통합 테스트**
-
-- [ ]  해당 ID 의 회원이 존재할 경우, 회원 정보가 반환된다.
-- [ ]  해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.
-
-**🌐 E2E 테스트**
-
-- [ ]  내 정보 조회에 성공할 경우, 해당하는 유저 정보를 응답으로 반환한다.
-- [ ]  존재하지 않는 ID 로 조회할 경우, `404 Not Found` 응답을 반환한다.
-
-### 포인트 조회
-
-**🔗 통합 테스트**
-
-- [ ]  해당 ID 의 회원이 존재할 경우, 보유 포인트가 반환된다.
-- [ ]  해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.
-
-**🌐 E2E 테스트**
-
-- [ ]  포인트 조회에 성공할 경우, 보유 포인트를 응답으로 반환한다.
-- [ ]  `X-USER-ID` 헤더가 없을 경우, `400 Bad Request` 응답을 반환한다.
diff --git a/apps/commerce-api/build.gradle.kts b/apps/commerce-api/build.gradle.kts
index 03ce68f0..9d7d11d8 100644
--- a/apps/commerce-api/build.gradle.kts
+++ b/apps/commerce-api/build.gradle.kts
@@ -9,6 +9,9 @@ dependencies {
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
+
+    // security
+    implementation("org.springframework.boot:spring-boot-starter-security")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 
     // querydsl
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
new file mode 100644
index 00000000..83ff27ad
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
@@ -0,0 +1,29 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+
+@RequiredArgsConstructor
+@Component
+public class MemberFacade {
+
+    private final MemberService memberService;
+
+    public MemberInfo register(String loginId, String rawPassword, String name,
+                               LocalDate birthDate, String email) {
+        Member member = memberService.register(loginId, rawPassword, name, birthDate, email);
+        return MemberInfo.from(member);
+    }
+
+    public MemberInfo getMe(Member authenticatedMember) {
+        return MemberInfo.fromWithMaskedName(authenticatedMember);
+    }
+
+    public void changePassword(Member authenticatedMember, String currentPassword, String newPassword) {
+        memberService.changePassword(authenticatedMember, currentPassword, newPassword);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
new file mode 100644
index 00000000..d6078e7a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
@@ -0,0 +1,35 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.Member;
+
+import java.time.LocalDate;
+
+public record MemberInfo(String loginId, String name, LocalDate birthDate, String email) {
+    public static MemberInfo from(Member member) {
+        return new MemberInfo(
+            member.getLoginId(),
+            member.getName(),
+            member.getBirthDate(),
+            member.getEmail()
+        );
+    }
+
+    public static MemberInfo fromWithMaskedName(Member member) {
+        return new MemberInfo(
+            member.getLoginId(),
+            maskName(member.getName()),
+            member.getBirthDate(),
+            member.getEmail()
+        );
+    }
+
+    private static String maskName(String name) {
+        if (name == null || name.isEmpty()) {
+            return "";
+        }
+        if (name.length() == 1) {
+            return "*";
+        }
+        return name.substring(0, name.length() - 1) + "*";
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java
new file mode 100644
index 00000000..70d1d50e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java
@@ -0,0 +1,142 @@
+package com.loopers.domain.member;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+import java.time.LocalDate;
+
+@Entity
+@Table(name = "member")
+public class Member extends BaseEntity {
+
+    @Column(unique = true, nullable = false)
+    private String loginId;
+    private String password;
+    private String name;
+    private LocalDate birthDate;
+    private String email;
+
+    protected Member() {}
+
+    private Member(String loginId, String password, String name,
+                   LocalDate birthDate, String email) {
+        this.loginId = loginId;
+        this.password = password;
+        this.name = name;
+        this.birthDate = birthDate;
+        this.email = email;
+    }
+
+    public static Member create(String loginId, String rawPassword,
+                                String name, LocalDate birthDate,
+                                String email, PasswordEncoder encoder) {
+        validateNotBlank(loginId, "로그인ID는 필수입니다.");
+        validateNotBlank(rawPassword, "비밀번호는 필수입니다.");
+        validateNotBlank(name, "이름은 필수입니다.");
+        validateNotNull(birthDate, "생년월일은 필수입니다.");
+        validateNotBlank(email, "이메일은 필수입니다.");
+
+        validateLoginId(loginId);
+        validatePassword(rawPassword, birthDate);
+        String normalizedName = normalizeName(name);
+        validateName(normalizedName);
+        validateEmail(email);
+
+        String encodedPassword = encoder.encode(rawPassword);
+        return new Member(loginId, encodedPassword, normalizedName, birthDate, email);
+    }
+
+    private static void validateNotNull(Object value, String message) {
+        if (value == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, message);
+        }
+    }
+
+    private static void validateNotBlank(String value, String message) {
+        if (value == null || value.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, message);
+        }
+    }
+
+    private static void validatePassword(String password, LocalDate birthDate) {
+        if (password.length() < 8 || password.length() > 16) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 8~16자여야 합니다.");
+        }
+        if (!password.matches("^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?]+$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 영문 대소문자, 숫자, 특수문자만 허용됩니다.");
+        }
+        String birthDateStr = birthDate.toString().replace("-", ""); // 19900115
+        if (password.contains(birthDateStr)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일을 포함할 수 없습니다.");
+        }
+    }
+
+    private static void validateLoginId(String loginId) {
+        if (!loginId.matches("^[a-zA-Z0-9]+$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인ID는 영문과 숫자만 허용됩니다.");
+        }
+    }
+
+    private static String normalizeName(String name) {
+        return name.trim().replaceAll("\\s+", " ");
+    }
+
+    private static void validateName(String name) {
+        boolean isKorean = name.matches("^[가-힣]+$");
+        boolean isEnglish = name.matches("^[a-zA-Z]+( [a-zA-Z]+)*$");
+
+        if (!isKorean && !isEnglish) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 한글만 또는 영문만 허용됩니다.");
+        }
+    }
+
+    private static void validateEmail(String email) {
+        if (!email.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "올바른 이메일 형식이 아닙니다.");
+        }
+    }
+
+    public void changePassword(String currentPassword, String newRawPassword,
+                               PasswordEncoder encoder) {
+        validateNotBlank(currentPassword, "현재 비밀번호는 필수입니다.");
+        validateNotBlank(newRawPassword, "새 비밀번호는 필수입니다.");
+
+        // 현재 비밀번호 확인
+        if (!encoder.matches(currentPassword, this.password)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호가 일치하지 않습니다.");
+        }
+        // 새 비밀번호가 현재와 동일한지 확인
+        if (encoder.matches(newRawPassword, this.password)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "새 비밀번호는 현재 비밀번호와 달라야 합니다.");
+        }
+        // 새 비밀번호 규칙 검증
+        validatePassword(newRawPassword, this.birthDate);
+        // 비밀번호 변경
+        this.password = encoder.encode(newRawPassword);
+    }
+
+    // Getter
+    public String getLoginId() {
+        return loginId;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public LocalDate getBirthDate() {
+        return birthDate;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberReader.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberReader.java
new file mode 100644
index 00000000..ef6b0660
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberReader.java
@@ -0,0 +1,8 @@
+package com.loopers.domain.member;
+
+import java.util.Optional;
+
+public interface MemberReader {
+    boolean existsByLoginId(String loginId);
+    Optional<Member> findByLoginId(String loginId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
new file mode 100644
index 00000000..39bd429e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
@@ -0,0 +1,5 @@
+package com.loopers.domain.member;
+
+public interface MemberRepository {
+    Member save(Member member);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
new file mode 100644
index 00000000..7ab5d49a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -0,0 +1,32 @@
+package com.loopers.domain.member;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+
+@RequiredArgsConstructor
+@Component
+public class MemberService {
+
+    private final MemberReader memberReader;
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    public Member register(String loginId, String rawPassword, String name,
+                           LocalDate birthDate, String email) {
+        if (memberReader.existsByLoginId(loginId)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이미 존재하는 로그인ID입니다.");
+        }
+
+        Member member = Member.create(loginId, rawPassword, name, birthDate, email, passwordEncoder);
+        return memberRepository.save(member);
+    }
+
+    public void changePassword(Member member, String currentPassword, String newPassword) {
+        member.changePassword(currentPassword, newPassword, passwordEncoder);
+        memberRepository.save(member);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/PasswordEncoder.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/PasswordEncoder.java
new file mode 100644
index 00000000..a28f6d47
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/PasswordEncoder.java
@@ -0,0 +1,6 @@
+package com.loopers.domain.member;
+
+public interface PasswordEncoder {
+    String encode(String rawPassword);
+    boolean matches(String rawPassword, String encodedPassword);
+}
\ No newline at end of file
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
new file mode 100644
index 00000000..ba8b089f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
@@ -0,0 +1,11 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface MemberJpaRepository extends JpaRepository<Member, Long> {
+    boolean existsByLoginId(String loginId);
+    Optional<Member> findByLoginId(String loginId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberReaderImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberReaderImpl.java
new file mode 100644
index 00000000..8dd8ce9c
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberReaderImpl.java
@@ -0,0 +1,24 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberReader;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class MemberReaderImpl implements MemberReader {
+    private final MemberJpaRepository memberJpaRepository;
+
+    @Override
+    public boolean existsByLoginId(String loginId) {
+        return memberJpaRepository.existsByLoginId(loginId);
+    }
+
+    @Override
+    public Optional<Member> findByLoginId(String loginId) {
+        return memberJpaRepository.findByLoginId(loginId);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
new file mode 100644
index 00000000..011b083d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
@@ -0,0 +1,17 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class MemberRepositoryImpl implements MemberRepository {
+    private final MemberJpaRepository memberJpaRepository;
+
+    @Override
+    public Member save(Member member) {
+        return memberJpaRepository.save(member);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/PasswordEncoderImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/PasswordEncoderImpl.java
new file mode 100644
index 00000000..e5275ed2
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/PasswordEncoderImpl.java
@@ -0,0 +1,20 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.PasswordEncoder;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Component;
+
+@Component
+public class PasswordEncoderImpl implements PasswordEncoder {
+    private final BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
+
+    @Override
+    public String encode(String rawPassword) {
+        return bCryptPasswordEncoder.encode(rawPassword);
+    }
+
+    @Override
+    public boolean matches(String rawPassword, String encodedPassword) {
+        return bCryptPasswordEncoder.matches(rawPassword, encodedPassword);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
new file mode 100644
index 00000000..daa8b42f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -0,0 +1,68 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.application.member.MemberFacade;
+import com.loopers.application.member.MemberInfo;
+import com.loopers.domain.member.Member;
+import com.loopers.interfaces.api.ApiResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.GetMapping;
+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.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/members")
+public class MemberV1Controller {
+
+    private final MemberFacade memberFacade;
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public ApiResponse<MemberV1Dto.MemberResponse> register(
+        @RequestBody MemberV1Dto.RegisterRequest request
+    ) {
+        MemberInfo info = memberFacade.register(
+            request.loginId(),
+            request.password(),
+            request.name(),
+            request.birthDate(),
+            request.email()
+        );
+        return ApiResponse.success(MemberV1Dto.MemberResponse.from(info));
+    }
+
+    @GetMapping("/me")
+    public ApiResponse<MemberV1Dto.MemberResponse> getMe(HttpServletRequest request) {
+        Member authenticatedMember = getAuthenticatedMember(request);
+        MemberInfo info = memberFacade.getMe(authenticatedMember);
+        return ApiResponse.success(MemberV1Dto.MemberResponse.from(info));
+    }
+
+    @PatchMapping("/me/password")
+    public ApiResponse<Void> changePassword(
+        HttpServletRequest request,
+        @RequestBody MemberV1Dto.ChangePasswordRequest passwordRequest
+    ) {
+        Member authenticatedMember = getAuthenticatedMember(request);
+        memberFacade.changePassword(
+            authenticatedMember,
+            passwordRequest.currentPassword(),
+            passwordRequest.newPassword()
+        );
+        return ApiResponse.success(null);
+    }
+
+    private Member getAuthenticatedMember(HttpServletRequest request) {
+        Object attribute = request.getAttribute("authenticatedMember");
+        if (attribute == null) {
+            throw new IllegalStateException("인증된 회원 정보가 없습니다.");
+        }
+        return (Member) attribute;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
new file mode 100644
index 00000000..9536c4d9
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
@@ -0,0 +1,43 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.application.member.MemberInfo;
+
+import java.time.LocalDate;
+
+public class MemberV1Dto {
+
+    public record RegisterRequest(
+        String loginId,
+        String password,
+        String name,
+        LocalDate birthDate,
+        String email
+    ) {}
+
+    public record ChangePasswordRequest(
+        String currentPassword,
+        String newPassword
+    ) {}
+
+    public record MemberResponse(
+        MemberDto member
+    ) {
+        public record MemberDto(
+            String loginId,
+            String name,
+            LocalDate birthDate,
+            String email
+        ) {}
+
+        public static MemberResponse from(MemberInfo info) {
+            return new MemberResponse(
+                new MemberDto(
+                    info.loginId(),
+                    info.name(),
+                    info.birthDate(),
+                    info.email()
+                )
+            );
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/auth/MemberAuthFilter.java b/apps/commerce-api/src/main/java/com/loopers/support/auth/MemberAuthFilter.java
new file mode 100644
index 00000000..a1e7cfb4
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/support/auth/MemberAuthFilter.java
@@ -0,0 +1,71 @@
+package com.loopers.support.auth;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberReader;
+import com.loopers.domain.member.PasswordEncoder;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@RequiredArgsConstructor
+@Component
+public class MemberAuthFilter extends OncePerRequestFilter {
+
+    private static final String HEADER_LOGIN_ID = "X-Loopers-LoginId";
+    private static final String HEADER_LOGIN_PW = "X-Loopers-LoginPw";
+
+    private final MemberReader memberReader;
+    private final PasswordEncoder passwordEncoder;
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
+                                    FilterChain filterChain) throws ServletException, IOException {
+        // 인증이 필요 없는 경로는 통과
+        if (!requiresAuthentication(request)) {
+            filterChain.doFilter(request, response);
+            return;
+        }
+
+        String loginId = request.getHeader(HEADER_LOGIN_ID);
+        String loginPw = request.getHeader(HEADER_LOGIN_PW);
+
+        // 헤더가 없으면 401
+        if (loginId == null || loginPw == null) {
+            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+            return;
+        }
+
+        // 회원 조회 및 비밀번호 검증
+        Member member = memberReader.findByLoginId(loginId)
+            .filter(m -> passwordEncoder.matches(loginPw, m.getPassword()))
+            .orElse(null);
+
+        if (member == null) {
+            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+            return;
+        }
+
+        // 인증 성공 - 회원 정보를 request에 저장
+        request.setAttribute("authenticatedMember", member);
+        filterChain.doFilter(request, response);
+    }
+
+    private boolean requiresAuthentication(HttpServletRequest request) {
+        String path = request.getRequestURI();
+        String method = request.getMethod();
+
+        // POST /api/v1/members (회원가입)는 인증 불필요
+        if ("POST".equals(method) && "/api/v1/members".equals(path)) {
+            return false;
+        }
+
+        // /api/v1/members/** 경로는 인증 필요
+        return path.startsWith("/api/v1/members/");
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/config/SecurityConfig.java b/apps/commerce-api/src/main/java/com/loopers/support/config/SecurityConfig.java
new file mode 100644
index 00000000..57ea9a04
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/support/config/SecurityConfig.java
@@ -0,0 +1,27 @@
+package com.loopers.support.config;
+
+import com.loopers.support.auth.MemberAuthFilter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+@RequiredArgsConstructor
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+    private final MemberAuthFilter memberAuthFilter;
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        return http
+            .csrf(csrf -> csrf.disable())
+            .authorizeHttpRequests(auth -> auth.anyRequest().permitAll())
+            .addFilterBefore(memberAuthFilter, UsernamePasswordAuthenticationFilter.class)
+            .build();
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceTest.java
new file mode 100644
index 00000000..b24151b7
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceTest.java
@@ -0,0 +1,122 @@
+package com.loopers.domain.member;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class MemberServiceTest {
+
+    private MemberService memberService;
+    private FakeMemberReader fakeMemberReader;
+    private FakeMemberRepository fakeMemberRepository;
+    private StubPasswordEncoder stubPasswordEncoder;
+
+    @BeforeEach
+    void setUp() {
+        fakeMemberReader = new FakeMemberReader();
+        fakeMemberRepository = new FakeMemberRepository();
+        stubPasswordEncoder = new StubPasswordEncoder();
+        memberService = new MemberService(fakeMemberReader, fakeMemberRepository, stubPasswordEncoder);
+    }
+
+    @DisplayName("회원가입 시, ")
+    @Nested
+    class Register {
+
+        @DisplayName("이미 존재하는 로그인ID로 가입하면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenLoginIdAlreadyExists() {
+            // Arrange
+            String existingLoginId = "existingUser";
+            fakeMemberReader.addExistingLoginId(existingLoginId);
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                memberService.register(
+                    existingLoginId, "Test1234!", "홍길동",
+                    LocalDate.of(1990, 1, 15), "test@example.com"
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("유효한 정보로 가입하면, 회원이 저장된다.")
+        @Test
+        void savesMember_whenAllFieldsAreValid() {
+            // Arrange
+            String loginId = "newUser";
+            String password = "Test1234!";
+            String name = "홍길동";
+            LocalDate birthDate = LocalDate.of(1990, 1, 15);
+            String email = "test@example.com";
+
+            // Act
+            Member member = memberService.register(loginId, password, name, birthDate, email);
+
+            // Assert
+            assertAll(
+                () -> assertThat(member.getLoginId()).isEqualTo(loginId),
+                () -> assertThat(member.getPassword()).isEqualTo("encoded_" + password),
+                () -> assertThat(member.getName()).isEqualTo(name),
+                () -> assertThat(member.getBirthDate()).isEqualTo(birthDate),
+                () -> assertThat(member.getEmail()).isEqualTo(email)
+            );
+        }
+    }
+
+    // Fake 구현체
+    static class FakeMemberReader implements MemberReader {
+        private final Map<String, Boolean> existingLoginIds = new HashMap<>();
+
+        void addExistingLoginId(String loginId) {
+            existingLoginIds.put(loginId, true);
+        }
+
+        @Override
+        public boolean existsByLoginId(String loginId) {
+            return existingLoginIds.containsKey(loginId);
+        }
+
+        @Override
+        public Optional<Member> findByLoginId(String loginId) {
+            return Optional.empty();
+        }
+    }
+
+    static class FakeMemberRepository implements MemberRepository {
+        private final Map<Long, Member> members = new HashMap<>();
+        private long idSequence = 1L;
+
+        @Override
+        public Member save(Member member) {
+            members.put(idSequence++, member);
+            return member;
+        }
+    }
+
+    static class StubPasswordEncoder implements PasswordEncoder {
+        @Override
+        public String encode(String rawPassword) {
+            return "encoded_" + rawPassword;
+        }
+
+        @Override
+        public boolean matches(String rawPassword, String encodedPassword) {
+            return encodedPassword.equals("encoded_" + rawPassword);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java
new file mode 100644
index 00000000..12c0b652
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java
@@ -0,0 +1,441 @@
+package com.loopers.domain.member;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class MemberTest {
+
+    private final PasswordEncoder stubEncoder = new PasswordEncoder() {
+        @Override
+        public String encode(String rawPassword) {
+            return "encoded_" + rawPassword;
+        }
+
+        @Override
+        public boolean matches(String rawPassword, String encodedPassword) {
+            return encodedPassword.equals("encoded_" + rawPassword);
+        }
+    };
+
+    @DisplayName("필수값 검증 시, ")
+    @Nested
+    class ValidateRequired {
+
+        @DisplayName("로그인ID가 null이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenLoginIdIsNull() {
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(null, "Test1234!", "홍길동",
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder);
+            });
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("로그인ID는 필수입니다.");
+        }
+
+        @DisplayName("로그인ID가 빈 문자열이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenLoginIdIsBlank() {
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create("  ", "Test1234!", "홍길동",
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder);
+            });
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("로그인ID는 필수입니다.");
+        }
+
+        @DisplayName("비밀번호가 null이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenPasswordIsNull() {
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create("testuser1", null, "홍길동",
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder);
+            });
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("비밀번호는 필수입니다.");
+        }
+
+        @DisplayName("이름이 null이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenNameIsNull() {
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create("testuser1", "Test1234!", null,
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder);
+            });
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("이름은 필수입니다.");
+        }
+
+        @DisplayName("생년월일이 null이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenBirthDateIsNull() {
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create("testuser1", "Test1234!", "홍길동",
+                    null, "test@example.com", stubEncoder);
+            });
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("생년월일은 필수입니다.");
+        }
+
+        @DisplayName("이메일이 null이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenEmailIsNull() {
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create("testuser1", "Test1234!", "홍길동",
+                    LocalDate.of(1990, 1, 15), null, stubEncoder);
+            });
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("이메일은 필수입니다.");
+        }
+    }
+
+    @DisplayName("회원을 생성할 때, ")
+    @Nested
+    class Create {
+
+        @DisplayName("모든 정보가 유효하면, 정상적으로 생성된다.")
+        @Test
+        void createsMember_whenAllFieldsAreValid() {
+            // Arrange
+            String loginId = "testuser1";
+            String password = "Test1234!";
+            String name = "홍길동";
+            LocalDate birthDate = LocalDate.of(1990, 1, 15);
+            String email = "test@example.com";
+
+            // Act
+            Member member = Member.create(
+                loginId, password, name, birthDate, email, stubEncoder
+            );
+
+            // Assert
+            assertAll(
+                () -> assertThat(member.getLoginId()).isEqualTo(loginId),
+                () -> assertThat(member.getPassword()).isEqualTo("encoded_" + password), // Stub이 반환한 값
+                () -> assertThat(member.getName()).isEqualTo(name),
+                () -> assertThat(member.getBirthDate()).isEqualTo(birthDate),
+                () -> assertThat(member.getEmail()).isEqualTo(email)
+            );
+        }
+    }
+
+    @DisplayName("로그인ID 검증 시, ")
+    @Nested
+    class ValidateLoginId {
+
+        @DisplayName("영문과 숫자 외 문자가 포함되면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenLoginIdContainsSpecialCharacters() {
+            // Arrange
+            String invalidLoginId = "test@user";
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(
+                    invalidLoginId, "Test1234!", "홍길동",
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+    }
+
+    @DisplayName("비밀번호 검증 시, ")
+    @Nested
+    class ValidatePassword {
+
+        @DisplayName("8자 미만이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenPasswordIsTooShort() {
+            // Arrange
+            String shortPassword = "Test12!"; // 7자
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(
+                    "testuser1", shortPassword, "홍길동",
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("16자 초과이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenPasswordIsTooLong() {
+            // Arrange
+            String longPassword = "Test1234!Test1234"; // 17자
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(
+                    "testuser1", longPassword, "홍길동",
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("허용되지 않은 문자(한글)가 포함되면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenPasswordContainsInvalidCharacters() {
+            // Arrange
+            String invalidPassword = "Test123한글!"; // 한글 포함
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(
+                    "testuser1", invalidPassword, "홍길동",
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("생년월일이 포함되면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenPasswordContainsBirthDate() {
+            // Arrange
+            LocalDate birthDate = LocalDate.of(1990, 1, 15);
+            String passwordWithBirthDate = "Test19900115!"; // 생년월일 포함
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(
+                    "testuser1", passwordWithBirthDate, "홍길동",
+                    birthDate, "test@example.com", stubEncoder
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+    }
+
+    @DisplayName("이름 검증 시, ")
+    @Nested
+    class ValidateName {
+
+        @DisplayName("한글과 영문이 혼합되면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenNameContainsMixedLanguages() {
+            // Arrange
+            String mixedName = "Hong길동";
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(
+                    "testuser1", "Test1234!", mixedName,
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("한글 이름에 공백이 포함되면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenKoreanNameContainsSpace() {
+            // Arrange
+            String koreanNameWithSpace = "홍 길동";
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(
+                    "testuser1", "Test1234!", koreanNameWithSpace,
+                    LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("영문 이름의 연속 공백은 하나로 정규화된다.")
+        @Test
+        void normalizesConsecutiveSpaces_whenEnglishNameHasMultipleSpaces() {
+            // Arrange
+            String nameWithConsecutiveSpaces = "John  Doe";
+
+            // Act
+            Member member = Member.create(
+                "testuser1", "Test1234!", nameWithConsecutiveSpaces,
+                LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder
+            );
+
+            // Assert
+            assertThat(member.getName()).isEqualTo("John Doe");
+        }
+    }
+
+    @DisplayName("이메일 검증 시, ")
+    @Nested
+    class ValidateEmail {
+
+        @DisplayName("올바르지 않은 형식이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenEmailFormatIsInvalid() {
+            // Arrange
+            String invalidEmail = "invalid-email";
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                Member.create(
+                    "testuser1", "Test1234!", "홍길동",
+                    LocalDate.of(1990, 1, 15), invalidEmail, stubEncoder
+                );
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+    }
+
+    @DisplayName("비밀번호 변경 시, ")
+    @Nested
+    class ChangePassword {
+
+        private Member createMember() {
+            return Member.create(
+                "testuser1", "Test1234!", "홍길동",
+                LocalDate.of(1990, 1, 15), "test@example.com", stubEncoder
+            );
+        }
+
+        @DisplayName("현재 비밀번호가 null이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenCurrentPasswordIsNull() {
+            // Arrange
+            Member member = createMember();
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                member.changePassword(null, "NewPass5678!", stubEncoder);
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("현재 비밀번호는 필수입니다.");
+        }
+
+        @DisplayName("새 비밀번호가 null이면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenNewPasswordIsNull() {
+            // Arrange
+            Member member = createMember();
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                member.changePassword("Test1234!", null, stubEncoder);
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("새 비밀번호는 필수입니다.");
+        }
+
+        @DisplayName("현재 비밀번호가 일치하지 않으면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenCurrentPasswordDoesNotMatch() {
+            // Arrange
+            Member member = createMember();
+            String wrongCurrentPassword = "WrongPass1!";
+            String newPassword = "NewPass5678!";
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                member.changePassword(wrongCurrentPassword, newPassword, stubEncoder);
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("현재 비밀번호가 일치하지 않습니다.");
+        }
+
+        @DisplayName("새 비밀번호가 현재 비밀번호와 동일하면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenNewPasswordIsSameAsCurrent() {
+            // Arrange
+            Member member = createMember();
+            String currentPassword = "Test1234!";
+            String samePassword = "Test1234!";
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                member.changePassword(currentPassword, samePassword, stubEncoder);
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("새 비밀번호는 현재 비밀번호와 달라야 합니다.");
+        }
+
+        @DisplayName("새 비밀번호가 규칙을 위반하면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenNewPasswordViolatesRules() {
+            // Arrange
+            Member member = createMember();
+            String currentPassword = "Test1234!";
+            String shortPassword = "short"; // 8자 미만
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                member.changePassword(currentPassword, shortPassword, stubEncoder);
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("새 비밀번호에 생년월일이 포함되면, BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequest_whenNewPasswordContainsBirthDate() {
+            // Arrange
+            Member member = createMember();
+            String currentPassword = "Test1234!";
+            String passwordWithBirthDate = "Pass19900115!"; // 생년월일 포함
+
+            // Act & Assert
+            CoreException exception = assertThrows(CoreException.class, () -> {
+                member.changePassword(currentPassword, passwordWithBirthDate, stubEncoder);
+            });
+
+            // Assert
+            assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+            assertThat(exception.getMessage()).isEqualTo("비밀번호에 생년월일을 포함할 수 없습니다.");
+        }
+
+        @DisplayName("모든 조건이 유효하면, 비밀번호가 정상적으로 변경된다.")
+        @Test
+        void changesPassword_whenAllConditionsAreValid() {
+            // Arrange
+            Member member = createMember();
+            String currentPassword = "Test1234!";
+            String newPassword = "NewPass5678!";
+
+            // Act
+            member.changePassword(currentPassword, newPassword, stubEncoder);
+
+            // Assert
+            assertThat(member.getPassword()).isEqualTo("encoded_" + newPassword);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
new file mode 100644
index 00000000..b1a7bc99
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
@@ -0,0 +1,409 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.infrastructure.member.MemberJpaRepository;
+import com.loopers.interfaces.api.member.MemberV1Dto;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class MemberV1ApiE2ETest {
+
+    private static final String ENDPOINT_REGISTER = "/api/v1/members";
+    private static final String ENDPOINT_ME = "/api/v1/members/me";
+    private static final String ENDPOINT_CHANGE_PASSWORD = "/api/v1/members/me/password";
+    private static final String HEADER_LOGIN_ID = "X-Loopers-LoginId";
+    private static final String HEADER_LOGIN_PW = "X-Loopers-LoginPw";
+
+    private final TestRestTemplate testRestTemplate;
+    private final MemberJpaRepository memberJpaRepository;
+    private final DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    public MemberV1ApiE2ETest(
+        TestRestTemplate testRestTemplate,
+        MemberJpaRepository memberJpaRepository,
+        DatabaseCleanUp databaseCleanUp
+    ) {
+        this.testRestTemplate = testRestTemplate;
+        this.memberJpaRepository = memberJpaRepository;
+        this.databaseCleanUp = databaseCleanUp;
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("POST /api/v1/members (회원가입)")
+    @Nested
+    class Register {
+
+        @DisplayName("유효한 정보로 회원가입하면, 201 Created 응답을 받는다.")
+        @Test
+        void returnsCreated_whenValidRequest() {
+            // arrange
+            MemberV1Dto.RegisterRequest request = new MemberV1Dto.RegisterRequest(
+                "testUser1",
+                "Test1234!",
+                "홍길동",
+                LocalDate.of(1990, 1, 15),
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.MemberResponse>> response = testRestTemplate.exchange(
+                ENDPOINT_REGISTER,
+                HttpMethod.POST,
+                new HttpEntity<>(request),
+                responseType
+            );
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED),
+                () -> assertThat(response.getBody().data().member().loginId()).isEqualTo("testUser1"),
+                () -> assertThat(memberJpaRepository.existsByLoginId("testUser1")).isTrue()
+            );
+        }
+
+        @DisplayName("이미 존재하는 로그인ID로 가입하면, 400 Bad Request 응답을 받는다.")
+        @Test
+        void returnsBadRequest_whenLoginIdAlreadyExists() {
+            // arrange - 먼저 회원가입
+            MemberV1Dto.RegisterRequest firstRequest = new MemberV1Dto.RegisterRequest(
+                "existingUser",
+                "Test1234!",
+                "홍길동",
+                LocalDate.of(1990, 1, 15),
+                "first@example.com"
+            );
+            testRestTemplate.exchange(
+                ENDPOINT_REGISTER,
+                HttpMethod.POST,
+                new HttpEntity<>(firstRequest),
+                new ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>>() {}
+            );
+
+            // arrange - 같은 로그인ID로 다시 가입 시도
+            MemberV1Dto.RegisterRequest duplicateRequest = new MemberV1Dto.RegisterRequest(
+                "existingUser",
+                "Test5678!",
+                "김철수",
+                LocalDate.of(1985, 5, 20),
+                "second@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.MemberResponse>> response = testRestTemplate.exchange(
+                ENDPOINT_REGISTER,
+                HttpMethod.POST,
+                new HttpEntity<>(duplicateRequest),
+                responseType
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+
+        @DisplayName("잘못된 이메일 형식으로 가입하면, 400 Bad Request 응답을 받는다.")
+        @Test
+        void returnsBadRequest_whenInvalidEmail() {
+            // arrange
+            MemberV1Dto.RegisterRequest request = new MemberV1Dto.RegisterRequest(
+                "testUser2",
+                "Test1234!",
+                "홍길동",
+                LocalDate.of(1990, 1, 15),
+                "invalid-email"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.MemberResponse>> response = testRestTemplate.exchange(
+                ENDPOINT_REGISTER,
+                HttpMethod.POST,
+                new HttpEntity<>(request),
+                responseType
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+    }
+
+    @DisplayName("GET /api/v1/members/me (내 정보 조회)")
+    @Nested
+    class GetMe {
+
+        @DisplayName("유효한 인증 헤더로 조회하면, 200 OK와 마스킹된 이름을 반환한다.")
+        @Test
+        void returnsOk_whenValidAuth() {
+            // arrange - 먼저 회원가입
+            String loginId = "testUser1";
+            String password = "Test1234!";
+            MemberV1Dto.RegisterRequest registerRequest = new MemberV1Dto.RegisterRequest(
+                loginId,
+                password,
+                "홍길동",
+                LocalDate.of(1990, 1, 15),
+                "test@example.com"
+            );
+            testRestTemplate.exchange(
+                ENDPOINT_REGISTER,
+                HttpMethod.POST,
+                new HttpEntity<>(registerRequest),
+                new ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>>() {}
+            );
+
+            // arrange - 인증 헤더 설정
+            HttpHeaders headers = new HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, loginId);
+            headers.set(HEADER_LOGIN_PW, password);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.MemberResponse>> response = testRestTemplate.exchange(
+                ENDPOINT_ME,
+                HttpMethod.GET,
+                new HttpEntity<>(headers),
+                responseType
+            );
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody().data().member().loginId()).isEqualTo(loginId),
+                () -> assertThat(response.getBody().data().member().name()).isEqualTo("홍길*"),  // 마스킹 확인
+                () -> assertThat(response.getBody().data().member().email()).isEqualTo("test@example.com")
+            );
+        }
+
+        @DisplayName("인증 헤더가 없으면, 401 Unauthorized 응답을 받는다.")
+        @Test
+        void returnsUnauthorized_whenNoAuthHeader() {
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.MemberResponse>> response = testRestTemplate.exchange(
+                ENDPOINT_ME,
+                HttpMethod.GET,
+                new HttpEntity<>(null),
+                responseType
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("잘못된 비밀번호로 조회하면, 401 Unauthorized 응답을 받는다.")
+        @Test
+        void returnsUnauthorized_whenWrongPassword() {
+            // arrange - 먼저 회원가입
+            String loginId = "testUser2";
+            MemberV1Dto.RegisterRequest registerRequest = new MemberV1Dto.RegisterRequest(
+                loginId,
+                "Test1234!",
+                "홍길동",
+                LocalDate.of(1990, 1, 15),
+                "test2@example.com"
+            );
+            testRestTemplate.exchange(
+                ENDPOINT_REGISTER,
+                HttpMethod.POST,
+                new HttpEntity<>(registerRequest),
+                new ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>>() {}
+            );
+
+            // arrange - 잘못된 비밀번호로 인증 헤더 설정
+            HttpHeaders headers = new HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, loginId);
+            headers.set(HEADER_LOGIN_PW, "WrongPassword1!");
+
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.MemberResponse>> response = testRestTemplate.exchange(
+                ENDPOINT_ME,
+                HttpMethod.GET,
+                new HttpEntity<>(headers),
+                responseType
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+    }
+
+    @DisplayName("PATCH /api/v1/members/me/password (비밀번호 수정)")
+    @Nested
+    class ChangePassword {
+
+        @DisplayName("유효한 요청으로 비밀번호를 수정하면, 200 OK 응답을 받는다.")
+        @Test
+        void returnsOk_whenValidRequest() {
+            // arrange - 먼저 회원가입
+            String loginId = "testUser1";
+            String currentPassword = "Test1234!";
+            String newPassword = "NewPass5678!";
+            registerMember(loginId, currentPassword);
+
+            // arrange - 인증 헤더와 요청 본문 설정
+            HttpHeaders headers = new HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, loginId);
+            headers.set(HEADER_LOGIN_PW, currentPassword);
+
+            MemberV1Dto.ChangePasswordRequest request = new MemberV1Dto.ChangePasswordRequest(
+                currentPassword,
+                newPassword
+            );
+
+            // act
+            ResponseEntity<ApiResponse<Void>> response = testRestTemplate.exchange(
+                ENDPOINT_CHANGE_PASSWORD,
+                HttpMethod.PATCH,
+                new HttpEntity<>(request, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert - 비밀번호 변경 성공
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+
+            // assert - 새 비밀번호로 인증 가능한지 확인
+            HttpHeaders newAuthHeaders = new HttpHeaders();
+            newAuthHeaders.set(HEADER_LOGIN_ID, loginId);
+            newAuthHeaders.set(HEADER_LOGIN_PW, newPassword);
+
+            ResponseEntity<ApiResponse<MemberV1Dto.MemberResponse>> meResponse = testRestTemplate.exchange(
+                ENDPOINT_ME,
+                HttpMethod.GET,
+                new HttpEntity<>(newAuthHeaders),
+                new ParameterizedTypeReference<>() {}
+            );
+            assertThat(meResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
+        }
+
+        @DisplayName("현재 비밀번호가 일치하지 않으면, 400 Bad Request 응답을 받는다.")
+        @Test
+        void returnsBadRequest_whenCurrentPasswordNotMatch() {
+            // arrange - 먼저 회원가입
+            String loginId = "testUser2";
+            String currentPassword = "Test1234!";
+            registerMember(loginId, currentPassword);
+
+            // arrange - 인증 헤더와 잘못된 현재 비밀번호로 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, loginId);
+            headers.set(HEADER_LOGIN_PW, currentPassword);
+
+            MemberV1Dto.ChangePasswordRequest request = new MemberV1Dto.ChangePasswordRequest(
+                "WrongCurrent1!",  // 잘못된 현재 비밀번호
+                "NewPass5678!"
+            );
+
+            // act
+            ResponseEntity<ApiResponse<Void>> response = testRestTemplate.exchange(
+                ENDPOINT_CHANGE_PASSWORD,
+                HttpMethod.PATCH,
+                new HttpEntity<>(request, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+
+        @DisplayName("새 비밀번호가 현재 비밀번호와 동일하면, 400 Bad Request 응답을 받는다.")
+        @Test
+        void returnsBadRequest_whenNewPasswordSameAsCurrent() {
+            // arrange - 먼저 회원가입
+            String loginId = "testUser3";
+            String currentPassword = "Test1234!";
+            registerMember(loginId, currentPassword);
+
+            // arrange - 인증 헤더와 동일한 비밀번호로 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, loginId);
+            headers.set(HEADER_LOGIN_PW, currentPassword);
+
+            MemberV1Dto.ChangePasswordRequest request = new MemberV1Dto.ChangePasswordRequest(
+                currentPassword,
+                currentPassword  // 현재 비밀번호와 동일
+            );
+
+            // act
+            ResponseEntity<ApiResponse<Void>> response = testRestTemplate.exchange(
+                ENDPOINT_CHANGE_PASSWORD,
+                HttpMethod.PATCH,
+                new HttpEntity<>(request, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+
+        @DisplayName("새 비밀번호가 규칙을 위반하면, 400 Bad Request 응답을 받는다.")
+        @Test
+        void returnsBadRequest_whenNewPasswordInvalid() {
+            // arrange - 먼저 회원가입
+            String loginId = "testUser4";
+            String currentPassword = "Test1234!";
+            registerMember(loginId, currentPassword);
+
+            // arrange - 인증 헤더와 규칙 위반 비밀번호로 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, loginId);
+            headers.set(HEADER_LOGIN_PW, currentPassword);
+
+            MemberV1Dto.ChangePasswordRequest request = new MemberV1Dto.ChangePasswordRequest(
+                currentPassword,
+                "short"  // 8자 미만
+            );
+
+            // act
+            ResponseEntity<ApiResponse<Void>> response = testRestTemplate.exchange(
+                ENDPOINT_CHANGE_PASSWORD,
+                HttpMethod.PATCH,
+                new HttpEntity<>(request, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+
+        private void registerMember(String loginId, String password) {
+            MemberV1Dto.RegisterRequest registerRequest = new MemberV1Dto.RegisterRequest(
+                loginId,
+                password,
+                "홍길동",
+                LocalDate.of(1990, 1, 15),
+                loginId + "@example.com"
+            );
+            testRestTemplate.exchange(
+                ENDPOINT_REGISTER,
+                HttpMethod.POST,
+                new HttpEntity<>(registerRequest),
+                new ParameterizedTypeReference<ApiResponse<MemberV1Dto.MemberResponse>>() {}
+            );
+        }
+    }
+
+}
diff --git a/http/commerce-api/member-v1.http b/http/commerce-api/member-v1.http
new file mode 100644
index 00000000..d0371357
--- /dev/null
+++ b/http/commerce-api/member-v1.http
@@ -0,0 +1,114 @@
+@baseUrl = http://localhost:8080
+
+### 회원가입 (정상)
+POST {{baseUrl}}/api/v1/members
+Content-Type: application/json
+
+{
+  "loginId": "testUser1",
+  "password": "Test1234!",
+  "name": "홍길동",
+  "birthDate": "1990-01-15",
+  "email": "test@example.com"
+}
+
+### 회원가입 (중복 ID 테스트 - 위 요청 먼저 실행 후)
+POST {{baseUrl}}/api/v1/members
+Content-Type: application/json
+
+{
+  "loginId": "testUser1",
+  "password": "Test5678!",
+  "name": "김철수",
+  "birthDate": "1985-05-20",
+  "email": "second@example.com"
+}
+
+### 회원가입 (잘못된 이메일)
+POST {{baseUrl}}/api/v1/members
+Content-Type: application/json
+
+{
+  "loginId": "testUser2",
+  "password": "Test1234!",
+  "name": "홍길동",
+  "birthDate": "1990-01-15",
+  "email": "invalid-email"
+}
+
+### 회원가입 (잘못된 비밀번호 - 너무 짧음)
+POST {{baseUrl}}/api/v1/members
+Content-Type: application/json
+
+{
+  "loginId": "testUser3",
+  "password": "short",
+  "name": "홍길동",
+  "birthDate": "1990-01-15",
+  "email": "test3@example.com"
+}
+
+###############################################
+# 내 정보 조회 API
+###############################################
+
+### 내 정보 조회 (정상 - 회원가입 먼저 실행 후)
+GET {{baseUrl}}/api/v1/members/me
+X-Loopers-LoginId: testUser1
+X-Loopers-LoginPw: Test1234!
+
+### 내 정보 조회 (인증 헤더 없음 - 401)
+GET {{baseUrl}}/api/v1/members/me
+
+### 내 정보 조회 (잘못된 비밀번호 - 401)
+GET {{baseUrl}}/api/v1/members/me
+X-Loopers-LoginId: testUser1
+X-Loopers-LoginPw: WrongPassword1!
+
+###############################################
+# 비밀번호 수정 API
+###############################################
+
+### 비밀번호 수정 (정상 - 회원가입 먼저 실행 후)
+PATCH {{baseUrl}}/api/v1/members/me/password
+Content-Type: application/json
+X-Loopers-LoginId: testUser1
+X-Loopers-LoginPw: Test1234!
+
+{
+  "currentPassword": "Test1234!",
+  "newPassword": "NewPass5678!"
+}
+
+### 비밀번호 수정 (현재 비밀번호 불일치 - 400)
+PATCH {{baseUrl}}/api/v1/members/me/password
+Content-Type: application/json
+X-Loopers-LoginId: testUser1
+X-Loopers-LoginPw: Test1234!
+
+{
+  "currentPassword": "WrongCurrent1!",
+  "newPassword": "NewPass5678!"
+}
+
+### 비밀번호 수정 (현재와 동일 - 400)
+PATCH {{baseUrl}}/api/v1/members/me/password
+Content-Type: application/json
+X-Loopers-LoginId: testUser1
+X-Loopers-LoginPw: Test1234!
+
+{
+  "currentPassword": "Test1234!",
+  "newPassword": "Test1234!"
+}
+
+### 비밀번호 수정 (규칙 위반 - 너무 짧음 - 400)
+PATCH {{baseUrl}}/api/v1/members/me/password
+Content-Type: application/json
+X-Loopers-LoginId: testUser1
+X-Loopers-LoginPw: Test1234!
+
+{
+  "currentPassword": "Test1234!",
+  "newPassword": "short"
+}