diff --git a/bookback/docs/architecture.md b/bookback/docs/architecture.md
index c38379e..b5554c2 100644
--- a/bookback/docs/architecture.md
+++ b/bookback/docs/architecture.md
@@ -14,13 +14,13 @@
 - [x] Связь сущностей между собой
 - [x] логирование и метрики
 - [x] Поиск книг по параметрам
+- [ ] Тогглер публикации книги/главы/страницы/параграфа
+
+
+**На потом:**
+- [ ] Сделать проверку чаптеров и страниц на последовательность номеров
 - [ ] Поиск глав по короткой ссылке
 - [ ] Ограничение доступа к книге\главе\странице\параграфу
 - [ ] Связь с сервисом авторизации
 - [ ] Связь с сервисом хранения файлов
 - [ ] Полнотекстовый поиск по книгам
-
-
-**Новое**
-- [ ] Сделать проверку чаптеров и страниц на последовательность номеров
-
diff --git a/bookback/internal/domain/entity/page.go b/bookback/internal/domain/entity/page.go
index d156a85..0dd4eae 100644
--- a/bookback/internal/domain/entity/page.go
+++ b/bookback/internal/domain/entity/page.go
@@ -32,7 +32,7 @@ func (p Page) AllFields() []string {
 
 // InsertOrUpdateFields возвращает список полей, используемых при вставке новой записи
 func (p Page) InsertOrUpdateFields() []string {
-	return []string{"title", "order", "text", "chapter_id", "is_public", "map_params_id"}
+	return []string{"title", "number", "text", "chapter_id", "is_public", "map_params_id"}
 }
 
 // EntityToInsertValues преобразует сущность Page в список значений для вставки
diff --git a/bookback/internal/domain/services/book_service.go b/bookback/internal/domain/services/book_service.go
index c39f9fd..4638a38 100644
--- a/bookback/internal/domain/services/book_service.go
+++ b/bookback/internal/domain/services/book_service.go
@@ -19,6 +19,7 @@ type BookService interface {
 	ListBooks(ctx context.Context, request models.RequestBook) ([]*models.Book, error)
 
 	GetTableOfContentsByBookID(ctx context.Context, request models.RequestTOC) (*models.TableOfContents, error)
+	TogglePublic(ctx context.Context, request models.ToggleBookRequest) (*models.Book, error)
 }
 
 type BookRepo interface {
@@ -123,6 +124,21 @@ func (s *bookService) GetTableOfContentsByBookID(ctx context.Context, request mo
 	return toc, nil
 }
 
+func (s *bookService) TogglePublic(ctx context.Context, request models.ToggleBookRequest) (*models.Book, error) {
+	book, err := s.repo.FindByID(ctx, request.BookID)
+	if err != nil {
+		return nil, err
+	}
+	
+	book.IsPublic = !book.IsPublic
+	book, err = s.repo.Update(ctx, request.BookID, book)
+	if err != nil {
+		return nil, err
+	}
+
+	return adapters.BookEntityToModel(book), nil
+}
+
 func joinSections(chapters, pages []*entity.Section) []*models.Section {
 	sections := make([]*models.Section, 0)
 	pageSectionSet := make(map[string][]*models.Section)
diff --git a/bookback/internal/domain/services/bookevents_service.go b/bookback/internal/domain/services/bookevents_service.go
index b5a7f48..08b5d2b 100644
--- a/bookback/internal/domain/services/bookevents_service.go
+++ b/bookback/internal/domain/services/bookevents_service.go
@@ -20,6 +20,8 @@ type BookEventsService interface {
 	GetBookEventsByChapterID(ctx context.Context, chapterID string, request models.RequestBookEvent) ([]*models.BookEvent, error)
 	GetBookEventsByPageID(ctx context.Context, pageID string, request models.RequestBookEvent) ([]*models.BookEvent, error)
 	GetBookEventsByParagraphID(ctx context.Context, paragraphID string, request models.RequestBookEvent) ([]*models.BookEvent, error)
+
+	TogglePublic(ctx context.Context, request models.ToggleBookEventRequest) (*models.BookEvent, error)
 }
 
 type bookEventsService struct {
@@ -30,6 +32,22 @@ func NewBookEventsService(repo SimpleRepo[*entity.BookEvent]) BookEventsService
 	return &bookEventsService{repo}
 }
 
+func (s *bookEventsService) TogglePublic(ctx context.Context, request models.ToggleBookEventRequest) (*models.BookEvent, error) {
+	bookEvent, err := s.repo.FindByID(ctx, request.BookEventID)
+	if err != nil {
+		return nil, err
+	}
+	bookEvent.IsPublic = !bookEvent.IsPublic
+	
+	var updated *entity.BookEvent
+	updated, err = s.repo.Update(ctx, request.BookEventID, bookEvent)
+	if err != nil {
+		return nil, err
+	}
+
+	return adapters.BookEventEntityToModel(updated), nil
+}
+
 func (s *bookEventsService) CreateBookEvent(ctx context.Context, request models.CreateBookEventRequest) (*models.BookEvent, error) {
 	bookEvent := adapters.BookEventModelToEntity(request.BookEvent)
 
diff --git a/bookback/internal/domain/services/chapter_service.go b/bookback/internal/domain/services/chapter_service.go
index 23f97a8..73b19d5 100644
--- a/bookback/internal/domain/services/chapter_service.go
+++ b/bookback/internal/domain/services/chapter_service.go
@@ -19,6 +19,8 @@ type ChapterService interface {
 	ListChapters(ctx context.Context, request models.RequestChapter) ([]*models.Chapter, error)
 
 	GetChapterByBookID(ctx context.Context, bookID string, request models.RequestChapter) ([]*models.Chapter, error)
+
+	TogglePublic(ctx context.Context, request models.ToggleChapterRequest) (*models.Chapter, error)
 }
 
 type chapterService struct {
@@ -29,6 +31,22 @@ func NewChapterService(chapterRepo SimpleRepo[*entity.Chapter]) ChapterService {
 	return &chapterService{chapterRepo: chapterRepo}
 }
 
+func (ch *chapterService) TogglePublic(ctx context.Context, request models.ToggleChapterRequest) (*models.Chapter, error) {
+	chapter, err := ch.chapterRepo.FindByID(ctx, request.ChapterID)
+	if err != nil {
+		return nil, err
+	}
+	chapter.IsPublic = !chapter.IsPublic
+
+	var updated *entity.Chapter
+	updated, err = ch.chapterRepo.Update(ctx, request.ChapterID, chapter)
+	if err != nil {
+		return nil, err
+	}
+
+	return adapters.ChapterEntityToModel(updated), nil
+}
+
 func (ch *chapterService) CreateChapter(ctx context.Context, request models.CreateChapterRequest) (*models.Chapter, error) {
 	chapter := adapters.ChapterModelToEntity(request.Chapter)
 
diff --git a/bookback/internal/domain/services/page_service.go b/bookback/internal/domain/services/page_service.go
index 1a769f5..6cd3f14 100644
--- a/bookback/internal/domain/services/page_service.go
+++ b/bookback/internal/domain/services/page_service.go
@@ -18,6 +18,8 @@ type PageService interface {
 	ListPages(ctx context.Context, request models.RequestPage) ([]*models.Page, error)
 
 	GetPagesByChapterID(ctx context.Context, chapterID string, request models.RequestPage) ([]*models.Page, error)
+
+	TogglePublic(ctx context.Context, request models.TogglePageRequest) (*models.Page, error)
 }
 
 type pageService struct {
@@ -28,6 +30,22 @@ func NewPageService(repo SimpleRepo[*entity.Page]) PageService {
 	return &pageService{repo}
 }
 
+func (s *pageService) TogglePublic(ctx context.Context, request models.TogglePageRequest) (*models.Page, error) {
+	page, err := s.repo.FindByID(ctx, request.PageID)
+	if err != nil {
+		return nil, err
+	}
+	page.IsPublic = !page.IsPublic
+
+	var updated *entity.Page
+	updated, err = s.repo.Update(ctx, request.PageID, page)
+	if err != nil {
+		return nil, err
+	}
+
+	return adapters.PageEntityToModel(updated), nil
+}
+
 func (s *pageService) CreatePage(ctx context.Context, request models.CreatePageRequest) (*models.Page, error) {
 	page := adapters.PageModelToEntity(request.Page)
 
diff --git a/bookback/internal/domain/services/paragraph_service.go b/bookback/internal/domain/services/paragraph_service.go
index 798d64c..4cf281c 100644
--- a/bookback/internal/domain/services/paragraph_service.go
+++ b/bookback/internal/domain/services/paragraph_service.go
@@ -17,6 +17,8 @@ type ParagraphService interface {
 	ListParagraphs(ctx context.Context, request models.RequestParagraph) ([]*models.Paragraph, error)
 
 	GetParagraphsByPageID(ctx context.Context, pageID string, request models.RequestParagraph) ([]*models.Paragraph, error)
+
+	TogglePublic(ctx context.Context, request models.ToggleParagraphRequest) (*models.Paragraph, error)
 }
 
 type paragraphService struct {
@@ -27,6 +29,22 @@ func NewParagraphService(repo SimpleRepo[*entity.Paragraph]) ParagraphService {
 	return &paragraphService{repo}
 }
 
+func (s *paragraphService) TogglePublic(ctx context.Context, request models.ToggleParagraphRequest) (*models.Paragraph, error) {
+	paragraph, err := s.repo.FindByID(ctx, request.ParagraphID)
+	if err != nil {
+		return nil, err
+	}
+	paragraph.IsPublic = !paragraph.IsPublic
+
+	var updated *entity.Paragraph
+	updated, err = s.repo.Update(ctx, request.ParagraphID, paragraph)
+	if err != nil {
+		return nil, err
+	}
+
+	return adapters.ParagraphEntityToModel(updated), nil
+}
+
 func (s *paragraphService) CreateParagraph(ctx context.Context, request models.CreateParagraphRequest) (*models.Paragraph, error) {
 	paragraph := adapters.ParagraphModelToEntity(request.Paragraph)
 
diff --git a/bookback/internal/infrastructure/http/v1/const.go b/bookback/internal/infrastructure/http/v1/const.go
index 52016c2..a546622 100644
--- a/bookback/internal/infrastructure/http/v1/const.go
+++ b/bookback/internal/infrastructure/http/v1/const.go
@@ -15,4 +15,5 @@ const (
 	BookSubPath    = "/book"
 	ChapterSubPath = "/chapter"
 	ListSubPath    = "/list"
+	ToggleSubPath  = "/toggle"
 )
diff --git a/bookback/internal/infrastructure/http/v1/controllers/book_controller.go b/bookback/internal/infrastructure/http/v1/controllers/book_controller.go
index aead683..4acf74d 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/book_controller.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/book_controller.go
@@ -2,6 +2,7 @@ package controllers
 
 import (
 	"context"
+	"fmt"
 	"github.com/SShlykov/zeitment/bookback/internal/infrastructure/http/v1/errors"
 	"github.com/SShlykov/zeitment/bookback/internal/models"
 	loggerPkg "github.com/SShlykov/zeitment/logger"
@@ -19,6 +20,7 @@ type bookService interface {
 	ListBooks(ctx context.Context, request models.RequestBook) ([]*models.Book, error)
 
 	GetTableOfContentsByBookID(ctx context.Context, request models.RequestTOC) (*models.TableOfContents, error)
+	TogglePublic(ctx context.Context, request models.ToggleBookRequest) (*models.Book, error)
 }
 
 // BookController структура для HTTP-контроллера книг.
@@ -34,6 +36,23 @@ func NewBookController(srv bookService, metric metrics.Metrics, logger loggerPkg
 	return &BookController{Service: srv, Metrics: metric, Logger: logger, Ctx: ctx}
 }
 
+func (bc *BookController) TogglePublic(c echo.Context) error {
+	var request models.ToggleBookRequest
+	if err := c.Bind(&request); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, errors.ValidationFailed)
+	}
+
+	book, err := bc.Service.TogglePublic(bc.Ctx, request)
+	if err != nil {
+		bc.Logger.Info("error", loggerPkg.Err(err))
+		bc.Metrics.IncCounter("controller.book.TogglePublic.error", err.Error())
+		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
+	}
+
+	fmt.Println("book", book)
+	return c.JSON(http.StatusOK, models.WebResponse[*models.Book]{Data: book, Status: "ok"})
+}
+
 func (bc *BookController) GetTableOfContentsByBookID(c echo.Context) error {
 	var request models.RequestTOC
 	if err := c.Bind(&request); err != nil {
@@ -72,7 +91,7 @@ func (bc *BookController) GetBookByID(c echo.Context) error {
 
 	book, err := bc.Service.GetBookByID(bc.Ctx, id)
 	if err != nil {
-		bc.Logger.Info("error", slog.String("id", id), slog.String("err", err.Error()))
+		bc.Logger.Info("error", slog.String("id", id), loggerPkg.Err(err))
 		bc.Metrics.IncCounter("controller.book.GetBookByID.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.BookNotFound)
 	}
@@ -88,7 +107,7 @@ func (bc *BookController) CreateBook(c echo.Context) error {
 
 	createdBook, err := bc.Service.CreateBook(bc.Ctx, request)
 	if err != nil {
-		bc.Logger.Info("error", slog.String("err", err.Error()))
+		bc.Logger.Info("error", loggerPkg.Err(err))
 		bc.Metrics.IncCounter("controller.book.CreateBook.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookNotCreated)
 	}
@@ -108,7 +127,7 @@ func (bc *BookController) UpdateBook(c echo.Context) error {
 
 	updatedBook, err := bc.Service.UpdateBook(bc.Ctx, id, request)
 	if err != nil {
-		bc.Logger.Info("error", slog.String("err", err.Error()))
+		bc.Logger.Info("error", loggerPkg.Err(err))
 		bc.Metrics.IncCounter("controller.book.UpdateBook.error", err.Error())
 		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
 	}
@@ -123,7 +142,7 @@ func (bc *BookController) DeleteBook(c echo.Context) error {
 
 	book, err := bc.Service.DeleteBook(bc.Ctx, id)
 	if err != nil {
-		bc.Logger.Info("error", slog.String("err", err.Error()))
+		bc.Logger.Info("error", loggerPkg.Err(err))
 		bc.Metrics.IncCounter("controller.book.DeleteBook.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookNotDeleted)
 	}
diff --git a/bookback/internal/infrastructure/http/v1/controllers/book_controller_test.go b/bookback/internal/infrastructure/http/v1/controllers/book_controller_test.go
index 1da874c..da37b32 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/book_controller_test.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/book_controller_test.go
@@ -24,7 +24,7 @@ func TestBookController_GetTableOfContentsByBookID(t *testing.T) {
 	service.EXPECT().GetTableOfContentsByBookID(gomock.Any(), gomock.Any()).Return(toc, nil)
 
 	e := echo.New()
-	req := httptest.NewRequest(http.MethodPost, v1.BooksPath+"/table_of_content", strings.NewReader(fixture.RequestPageOptions))
+	req := httptest.NewRequest(http.MethodPost, v1.BooksPath+v1.ToggleSubPath, strings.NewReader(fixture.RequestPageOptions))
 	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
 	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec)
diff --git a/bookback/internal/infrastructure/http/v1/controllers/bookevents_controller.go b/bookback/internal/infrastructure/http/v1/controllers/bookevents_controller.go
index 2a3e03c..1ef1249 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/bookevents_controller.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/bookevents_controller.go
@@ -7,7 +7,6 @@ import (
 	loggerPkg "github.com/SShlykov/zeitment/logger"
 	"github.com/SShlykov/zeitment/metrics"
 	"github.com/labstack/echo/v4"
-	"log/slog"
 	"net/http"
 )
 
@@ -21,6 +20,8 @@ type bookEventService interface {
 	GetBookEventsByChapterID(ctx context.Context, chapterID string, request models.RequestBookEvent) ([]*models.BookEvent, error)
 	GetBookEventsByPageID(ctx context.Context, pageID string, request models.RequestBookEvent) ([]*models.BookEvent, error)
 	GetBookEventsByParagraphID(ctx context.Context, paragraphID string, request models.RequestBookEvent) ([]*models.BookEvent, error)
+
+	TogglePublic(ctx context.Context, request models.ToggleBookEventRequest) (*models.BookEvent, error)
 }
 
 // BookEventController структура для HTTP-контроллера событий книги.
@@ -37,6 +38,22 @@ func NewBookEventController(srv bookEventService, metric metrics.Metrics,
 	return &BookEventController{Service: srv, Metrics: metric, Logger: logger, Ctx: ctx}
 }
 
+func (bec *BookEventController) TogglePublic(c echo.Context) error {
+	var request models.ToggleBookEventRequest
+	if err := c.Bind(&request); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, errors.ValidationFailed)
+	}
+
+	event, err := bec.Service.TogglePublic(bec.Ctx, request)
+	if err != nil {
+		bec.Logger.Info("error", loggerPkg.Err(err))
+		bec.Metrics.IncCounter("controller.BookEvent.TogglePublic.error", err.Error())
+		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
+	}
+
+	return c.JSON(http.StatusOK, models.WebResponse[*models.BookEvent]{Data: event, Status: "ok"})
+}
+
 func (bec *BookEventController) GetBookEventByID(c echo.Context) error {
 	id := c.Param("id")
 	if id == "" {
@@ -45,7 +62,7 @@ func (bec *BookEventController) GetBookEventByID(c echo.Context) error {
 
 	event, err := bec.Service.GetBookEventByID(bec.Ctx, id)
 	if err != nil {
-		bec.Logger.Info("error", slog.String("err", err.Error()))
+		bec.Logger.Info("error", loggerPkg.Err(err))
 		bec.Metrics.IncCounter("controller.BookEvent.GetBookEventByID.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookEventNotFound)
 	}
@@ -61,7 +78,7 @@ func (bec *BookEventController) CreateBookEvent(c echo.Context) error {
 
 	createdEvent, err := bec.Service.CreateBookEvent(bec.Ctx, request)
 	if err != nil {
-		bec.Logger.Info("error", slog.String("err", err.Error()))
+		bec.Logger.Info("error", loggerPkg.Err(err))
 		bec.Metrics.IncCounter("controller.BookEvent.CreateBookEvent.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookEventNotCreated)
 	}
@@ -81,7 +98,7 @@ func (bec *BookEventController) UpdateBookEvent(c echo.Context) error {
 
 	event, err := bec.Service.UpdateBookEvent(bec.Ctx, id, request)
 	if err != nil {
-		bec.Logger.Info("error", slog.String("err", err.Error()))
+		bec.Logger.Info("error", loggerPkg.Err(err))
 		bec.Metrics.IncCounter("controller.BookEvent.UpdateBookEvent.error", err.Error())
 		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
 	}
@@ -97,7 +114,7 @@ func (bec *BookEventController) DeleteBookEvent(c echo.Context) error {
 
 	deletedEvent, err := bec.Service.DeleteBookEvent(bec.Ctx, id)
 	if err != nil {
-		bec.Logger.Info("error", slog.String("err", err.Error()))
+		bec.Logger.Info("error", loggerPkg.Err(err))
 		bec.Metrics.IncCounter("controller.BookEvent.DeleteBookEvent.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookEventNotDeleted)
 	}
@@ -118,7 +135,7 @@ func (bec *BookEventController) GetBookEventsByBookID(c echo.Context) error {
 
 	events, err := bec.Service.GetBookEventsByBookID(bec.Ctx, id, request)
 	if err != nil {
-		bec.Logger.Info("error", slog.String("err", err.Error()))
+		bec.Logger.Info("error", loggerPkg.Err(err))
 		bec.Metrics.IncCounter("controller.BookEvent.GetBookEventsByBookID.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookEventNotFound)
 	}
@@ -138,7 +155,7 @@ func (bec *BookEventController) GetBookEventsByChapterID(c echo.Context) error {
 
 	events, err := bec.Service.GetBookEventsByChapterID(bec.Ctx, id, request)
 	if err != nil {
-		bec.Logger.Info("error", slog.String("err", err.Error()))
+		bec.Logger.Info("error", loggerPkg.Err(err))
 		bec.Metrics.IncCounter("controller.BookEvent.GetBookEventsByChapterID.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookEventNotFound)
 	}
@@ -159,7 +176,7 @@ func (bec *BookEventController) GetBookEventsByPageID(c echo.Context) error {
 
 	events, err := bec.Service.GetBookEventsByPageID(bec.Ctx, id, request)
 	if err != nil {
-		bec.Logger.Info("error", slog.String("err", err.Error()))
+		bec.Logger.Info("error", loggerPkg.Err(err))
 		bec.Metrics.IncCounter("controller.BookEvent.GetBookEventsByPageID.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookEventNotFound)
 	}
@@ -180,7 +197,7 @@ func (bec *BookEventController) GetBookEventsByParagraphID(c echo.Context) error
 
 	events, err := bec.Service.GetBookEventsByParagraphID(bec.Ctx, id, request)
 	if err != nil {
-		bec.Logger.Info("error", slog.String("err", err.Error()))
+		bec.Logger.Info("error", loggerPkg.Err(err))
 		bec.Metrics.IncCounter("controller.BookEvent.GetBookEventsByPageID.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.BookEventNotFound)
 	}
diff --git a/bookback/internal/infrastructure/http/v1/controllers/bookevents_controller_test.go b/bookback/internal/infrastructure/http/v1/controllers/bookevents_controller_test.go
index 59b93bb..04a5156 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/bookevents_controller_test.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/bookevents_controller_test.go
@@ -13,6 +13,35 @@ import (
 	"testing"
 )
 
+func TestBookEventController_TogglePublic(t *testing.T) {
+	t.Parallel()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	fixture := NewTestFixture(v1.BookEventsPath)
+
+	service := mocks.NewMockBookEventsService(ctrl)
+	bookEvent := &models.BookEvent{ID: fixture.ID}
+	service.EXPECT().TogglePublic(gomock.Any(), gomock.Any()).Return(bookEvent, nil)
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodPost, v1.BookEventsPath+v1.ToggleSubPath, strings.NewReader(fixture.RequestPageOptions))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	bc := NewBookEventController(service, fixture.Metrics, fixture.Logger, fixture.Context)
+	err := bc.TogglePublic(c)
+	if err != nil {
+		return
+	}
+
+	assert.Empty(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.True(t, strings.Contains(rec.Body.String(), `"status":"ok"`))
+	assert.True(t, strings.Contains(rec.Body.String(), `"data":`))
+	assert.True(t, strings.Contains(rec.Body.String(), fixture.ID))
+}
+
 func TestBookEventController_GetBookEventByID(t *testing.T) {
 	t.Parallel()
 	ctrl := gomock.NewController(t)
diff --git a/bookback/internal/infrastructure/http/v1/controllers/chapter_controller.go b/bookback/internal/infrastructure/http/v1/controllers/chapter_controller.go
index bf5a55f..8a137c0 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/chapter_controller.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/chapter_controller.go
@@ -7,7 +7,6 @@ import (
 	loggerPkg "github.com/SShlykov/zeitment/logger"
 	"github.com/SShlykov/zeitment/metrics"
 	"github.com/labstack/echo/v4"
-	"log/slog"
 	"net/http"
 )
 
@@ -18,6 +17,8 @@ type chapterService interface {
 	DeleteChapter(ctx context.Context, id string) (*models.Chapter, error)
 	ListChapters(ctx context.Context, request models.RequestChapter) ([]*models.Chapter, error)
 	GetChapterByBookID(ctx context.Context, bookID string, request models.RequestChapter) ([]*models.Chapter, error)
+
+	TogglePublic(ctx context.Context, request models.ToggleChapterRequest) (*models.Chapter, error)
 }
 
 type ChapterController struct {
@@ -32,6 +33,21 @@ func NewChapterController(srv chapterService, metric metrics.Metrics, logger log
 	return &ChapterController{Service: srv, Metrics: metric, Logger: logger, Ctx: ctx}
 }
 
+func (ch *ChapterController) TogglePublic(c echo.Context) error {
+	var request models.ToggleChapterRequest
+	if err := c.Bind(&request); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, errors.ValidationFailed)
+	}
+
+	chapter, err := ch.Service.TogglePublic(ch.Ctx, request)
+	if err != nil {
+		ch.Logger.Info("error", loggerPkg.Err(err))
+		ch.Metrics.IncCounter("controller.chapter.TogglePublic.error", err.Error())
+		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
+	}
+	return c.JSON(http.StatusOK, models.WebResponse[*models.Chapter]{Data: chapter, Status: "ok"})
+}
+
 func (ch *ChapterController) ListChapters(c echo.Context) error {
 	var request models.RequestChapter
 	if err := c.Bind(&request); err != nil {
@@ -40,7 +56,7 @@ func (ch *ChapterController) ListChapters(c echo.Context) error {
 
 	chapters, err := ch.Service.ListChapters(ch.Ctx, request)
 	if err != nil {
-		ch.Logger.Info("error", slog.String("err", err.Error()))
+		ch.Logger.Info("error", loggerPkg.Err(err))
 		ch.Metrics.IncCounter("controller.chapter.ListChapters.error", err.Error())
 		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
 	}
@@ -55,7 +71,7 @@ func (ch *ChapterController) CreateChapter(c echo.Context) error {
 
 	createdChapter, err := ch.Service.CreateChapter(ch.Ctx, chap)
 	if err != nil {
-		ch.Logger.Info("error", slog.String("err", err.Error()))
+		ch.Logger.Info("error", loggerPkg.Err(err))
 		ch.Metrics.IncCounter("controller.chapter.CreateChapter.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.ChapterNotCreated)
 	}
@@ -70,7 +86,7 @@ func (ch *ChapterController) GetChapterByID(c echo.Context) error {
 
 	chapter, err := ch.Service.GetChapterByID(ch.Ctx, id)
 	if err != nil {
-		ch.Logger.Info("error", slog.String("err", err.Error()))
+		ch.Logger.Info("error", loggerPkg.Err(err))
 		ch.Metrics.IncCounter("controller.chapter.GetChapterByID.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.ChapterNotFound)
 	}
@@ -90,7 +106,7 @@ func (ch *ChapterController) UpdateChapter(c echo.Context) error {
 
 	chapter, err := ch.Service.UpdateChapter(ch.Ctx, id, request)
 	if err != nil {
-		ch.Logger.Info("error", slog.String("err", err.Error()))
+		ch.Logger.Info("error", loggerPkg.Err(err))
 		ch.Metrics.IncCounter("controller.chapter.UpdateChapter.error", err.Error())
 		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
 	}
@@ -105,7 +121,7 @@ func (ch *ChapterController) DeleteChapter(c echo.Context) error {
 
 	chapter, err := ch.Service.DeleteChapter(ch.Ctx, id)
 	if err != nil {
-		ch.Logger.Info("error", slog.String("err", err.Error()))
+		ch.Logger.Info("error", loggerPkg.Err(err))
 		ch.Metrics.IncCounter("controller.chapter.DeleteChapter.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotAcceptable, errors.ChapterNotDeleted)
 	}
@@ -125,7 +141,7 @@ func (ch *ChapterController) GetChapterByBookID(c echo.Context) error {
 
 	chapters, err := ch.Service.GetChapterByBookID(ch.Ctx, id, request)
 	if err != nil {
-		ch.Logger.Info("error", slog.String("err", err.Error()))
+		ch.Logger.Info("error", loggerPkg.Err(err))
 		ch.Metrics.IncCounter("controller.chapter.DeleteChapter.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.ChapterNotFound)
 	}
diff --git a/bookback/internal/infrastructure/http/v1/controllers/chapter_controller_test.go b/bookback/internal/infrastructure/http/v1/controllers/chapter_controller_test.go
index fab23fc..f8b7422 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/chapter_controller_test.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/chapter_controller_test.go
@@ -13,6 +13,35 @@ import (
 	"testing"
 )
 
+func TestChapterController_TogglePublic(t *testing.T) {
+	t.Parallel()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	fixture := NewTestFixture(v1.ChaptersPath)
+
+	service := mocks.NewMockChapterService(ctrl)
+	chapter := &models.Chapter{ID: fixture.ID}
+	service.EXPECT().TogglePublic(gomock.Any(), gomock.Any()).Return(chapter, nil)
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodPost, v1.ChaptersPath+v1.ToggleSubPath, strings.NewReader(fixture.RequestPageOptions))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	cc := NewChapterController(service, fixture.Metrics, fixture.Logger, fixture.Context)
+	err := cc.TogglePublic(c)
+	if err != nil {
+		return
+	}
+
+	assert.Empty(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.True(t, strings.Contains(rec.Body.String(), `"status":"ok"`))
+	assert.True(t, strings.Contains(rec.Body.String(), `"data":`))
+	assert.True(t, strings.Contains(rec.Body.String(), fixture.ID))
+}
+
 func TestChapterController_ListChapters(t *testing.T) {
 	t.Parallel()
 	ctrl := gomock.NewController(t)
diff --git a/bookback/internal/infrastructure/http/v1/controllers/mapvariables_controller.go b/bookback/internal/infrastructure/http/v1/controllers/mapvariables_controller.go
index 2f6de95..03dbe26 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/mapvariables_controller.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/mapvariables_controller.go
@@ -7,7 +7,6 @@ import (
 	loggerPkg "github.com/SShlykov/zeitment/logger"
 	"github.com/SShlykov/zeitment/metrics"
 	"github.com/labstack/echo/v4"
-	"log/slog"
 	"net/http"
 )
 
@@ -44,7 +43,7 @@ func (mvc *MapVariablesController) GetMapVariableByID(c echo.Context) error {
 
 	variable, err := mvc.Service.GetMapVariableByID(mvc.Ctx, id)
 	if err != nil {
-		mvc.Logger.Info("error", slog.String("err", err.Error()))
+		mvc.Logger.Info("error", loggerPkg.Err(err))
 		mvc.Metrics.IncCounter("controller.MapVariablesController.GetMapVariableByID.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.MapVariablesNotFound)
 	}
@@ -65,7 +64,7 @@ func (mvc *MapVariablesController) UpdateMapVariable(c echo.Context) error {
 
 	variable, err := mvc.Service.UpdateMapVariable(mvc.Ctx, id, request)
 	if err != nil {
-		mvc.Logger.Info("error", slog.String("err", err.Error()))
+		mvc.Logger.Info("error", loggerPkg.Err(err))
 		mvc.Metrics.IncCounter("controller.MapVariablesController.UpdateMapVariable.error", err.Error())
 		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
 	}
@@ -81,7 +80,7 @@ func (mvc *MapVariablesController) DeleteMapVariable(c echo.Context) error {
 
 	variable, err := mvc.Service.DeleteMapVariable(mvc.Ctx, id)
 	if err != nil {
-		mvc.Logger.Info("error", slog.String("err", err.Error()))
+		mvc.Logger.Info("error", loggerPkg.Err(err))
 		mvc.Metrics.IncCounter("controller.MapVariablesController.DeleteMapVariable.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.MapVariablesNotDeleted)
 	}
@@ -102,7 +101,7 @@ func (mvc *MapVariablesController) GetMapVariablesByBookID(c echo.Context) error
 
 	variables, err := mvc.Service.GetMapVariablesByBookID(mvc.Ctx, id, request)
 	if err != nil {
-		mvc.Logger.Info("error", slog.String("err", err.Error()))
+		mvc.Logger.Info("error", loggerPkg.Err(err))
 		mvc.Metrics.IncCounter("controller.MapVariablesController.GetMapVariablesByBookID.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.MapVariablesNotFound)
 	}
@@ -123,7 +122,7 @@ func (mvc *MapVariablesController) GetMapVariablesByChapterID(c echo.Context) er
 
 	variables, err := mvc.Service.GetMapVariablesByChapterID(mvc.Ctx, id, request)
 	if err != nil {
-		mvc.Logger.Info("error", slog.String("err", err.Error()))
+		mvc.Logger.Info("error", loggerPkg.Err(err))
 		mvc.Metrics.IncCounter("controller.MapVariablesController.GetMapVariablesByChapterID.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.MapVariablesNotFound)
 	}
@@ -144,7 +143,7 @@ func (mvc *MapVariablesController) GetMapVariablesByPageID(c echo.Context) error
 
 	variables, err := mvc.Service.GetMapVariablesByPageID(mvc.Ctx, id, request)
 	if err != nil {
-		mvc.Logger.Info("error", slog.String("err", err.Error()))
+		mvc.Logger.Info("error", loggerPkg.Err(err))
 		mvc.Metrics.IncCounter("controller.MapVariablesController.GetMapVariablesByPageID.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.MapVariablesNotFound)
 	}
@@ -165,7 +164,7 @@ func (mvc *MapVariablesController) GetMapVariablesByParagraphID(c echo.Context)
 
 	variables, err := mvc.Service.GetMapVariablesByParagraphID(mvc.Ctx, id, request)
 	if err != nil {
-		mvc.Logger.Info("error", slog.String("err", err.Error()))
+		mvc.Logger.Info("error", loggerPkg.Err(err))
 		mvc.Metrics.IncCounter("controller.MapVariablesController.GetMapVariablesByParagraphID.error", err.Error())
 		return echo.NewHTTPError(http.StatusNotFound, errors.MapVariablesNotFound)
 	}
@@ -181,7 +180,7 @@ func (mvc *MapVariablesController) CreateMapVariable(c echo.Context) error {
 
 	variable, err := mvc.Service.CreateMapVariable(mvc.Ctx, request)
 	if err != nil {
-		mvc.Logger.Info("error", slog.String("err", err.Error()))
+		mvc.Logger.Info("error", loggerPkg.Err(err))
 		mvc.Metrics.IncCounter("controller.MapVariablesController.CreateMapVariable.error", err.Error())
 		return echo.NewHTTPError(http.StatusBadRequest, errors.MapVariablesNotCreated)
 	}
diff --git a/bookback/internal/infrastructure/http/v1/controllers/page_controller.go b/bookback/internal/infrastructure/http/v1/controllers/page_controller.go
index 5a2256f..a20204a 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/page_controller.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/page_controller.go
@@ -17,6 +17,8 @@ type pageService interface {
 	DeletePage(ctx context.Context, id string) (*models.Page, error)
 	ListPages(ctx context.Context, page models.RequestPage) ([]*models.Page, error)
 	GetPagesByChapterID(ctx context.Context, chapterID string, page models.RequestPage) ([]*models.Page, error)
+
+	TogglePublic(ctx context.Context, request models.TogglePageRequest) (*models.Page, error)
 }
 
 type PageController struct {
@@ -30,6 +32,21 @@ func NewPageController(srv pageService, metric metrics.Metrics, logger loggerPkg
 	return &PageController{Service: srv, Metrics: metric, Logger: logger, Ctx: ctx}
 }
 
+func (p *PageController) TogglePublic(c echo.Context) error {
+	var request models.TogglePageRequest
+	if err := c.Bind(&request); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, errors.ValidationFailed)
+	}
+
+	page, err := p.Service.TogglePublic(p.Ctx, request)
+	if err != nil {
+		p.Logger.Info("error", loggerPkg.Err(err))
+		p.Metrics.IncCounter("controller.Page.TogglePublic.error", err.Error())
+		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
+	}
+	return c.JSON(http.StatusOK, models.WebResponse[*models.Page]{Data: page, Status: "ok"})
+}
+
 func (p *PageController) ListPages(c echo.Context) error {
 	var request models.RequestPage
 	if err := c.Bind(&request); err != nil {
diff --git a/bookback/internal/infrastructure/http/v1/controllers/page_controller_test.go b/bookback/internal/infrastructure/http/v1/controllers/page_controller_test.go
index 1f0d728..e0b6827 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/page_controller_test.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/page_controller_test.go
@@ -13,6 +13,32 @@ import (
 	"testing"
 )
 
+func TestPageController_TogglePublic(t *testing.T) {
+	t.Parallel()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	fixture := NewTestFixture(v1.PagesPath)
+
+	service := mocks.NewMockPageService(ctrl)
+	page := &models.Page{ID: fixture.ID}
+	service.EXPECT().TogglePublic(gomock.Any(), gomock.Any()).Return(page, nil)
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodPost, v1.PagesPath+v1.ToggleSubPath, strings.NewReader(fixture.RequestPageOptions))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	cc := NewPageController(service, fixture.Metrics, fixture.Logger, fixture.Context)
+	err := cc.TogglePublic(c)
+
+	assert.Empty(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.True(t, strings.Contains(rec.Body.String(), `"status":"ok"`))
+	assert.True(t, strings.Contains(rec.Body.String(), `"data":`))
+	assert.True(t, strings.Contains(rec.Body.String(), fixture.ID))
+}
+
 func TestPageController_ListPages(t *testing.T) {
 	t.Parallel()
 	ctrl := gomock.NewController(t)
diff --git a/bookback/internal/infrastructure/http/v1/controllers/paragraph_controller.go b/bookback/internal/infrastructure/http/v1/controllers/paragraph_controller.go
index 53f2a45..d604353 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/paragraph_controller.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/paragraph_controller.go
@@ -17,6 +17,8 @@ type paragraphService interface {
 	DeleteParagraph(ctx context.Context, id string) (*models.Paragraph, error)
 	ListParagraphs(ctx context.Context, request models.RequestParagraph) ([]*models.Paragraph, error)
 	GetParagraphsByPageID(ctx context.Context, pageID string, request models.RequestParagraph) ([]*models.Paragraph, error)
+
+	TogglePublic(ctx context.Context, request models.ToggleParagraphRequest) (*models.Paragraph, error)
 }
 
 type ParagraphController struct {
@@ -32,6 +34,21 @@ func NewParagraphController(srv paragraphService, metric metrics.Metrics,
 	return &ParagraphController{Service: srv, Metrics: metric, Logger: logger, Ctx: ctx}
 }
 
+func (p *ParagraphController) TogglePublic(c echo.Context) error {
+	var request models.ToggleParagraphRequest
+	if err := c.Bind(&request); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, errors.ValidationFailed)
+	}
+
+	paragraph, err := p.Service.TogglePublic(p.Ctx, request)
+	if err != nil {
+		p.Logger.Info("error", loggerPkg.Err(err))
+		p.Metrics.IncCounter("controller.Paragraph.TogglePublic.error", err.Error())
+		return echo.NewHTTPError(http.StatusInternalServerError, errors.Unknown)
+	}
+	return c.JSON(http.StatusOK, models.WebResponse[*models.Paragraph]{Data: paragraph, Status: "ok"})
+}
+
 func (p *ParagraphController) ListParagraphs(c echo.Context) error {
 	var request models.RequestParagraph
 	if err := c.Bind(&request); err != nil {
diff --git a/bookback/internal/infrastructure/http/v1/controllers/paragraph_controller_test.go b/bookback/internal/infrastructure/http/v1/controllers/paragraph_controller_test.go
index 2cc834d..eed8ca3 100644
--- a/bookback/internal/infrastructure/http/v1/controllers/paragraph_controller_test.go
+++ b/bookback/internal/infrastructure/http/v1/controllers/paragraph_controller_test.go
@@ -13,6 +13,32 @@ import (
 	"testing"
 )
 
+func TestParagraphController_TogglePublic(t *testing.T) {
+	t.Parallel()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	fixture := NewTestFixture(v1.ParagraphsPath)
+
+	service := mocks.NewMockParagraphService(ctrl)
+	paragraph := &models.Paragraph{ID: fixture.ID}
+	service.EXPECT().TogglePublic(gomock.Any(), gomock.Any()).Return(paragraph, nil)
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodPost, v1.ParagraphsPath+v1.ToggleSubPath, strings.NewReader(fixture.RequestPageOptions))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	cc := NewParagraphController(service, fixture.Metrics, fixture.Logger, fixture.Context)
+	err := cc.TogglePublic(c)
+
+	assert.Empty(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.True(t, strings.Contains(rec.Body.String(), `"status":"ok"`))
+	assert.True(t, strings.Contains(rec.Body.String(), `"data":`))
+	assert.True(t, strings.Contains(rec.Body.String(), fixture.ID))
+}
+
 func TestParagraphController_CreateParagraph(t *testing.T) {
 	t.Parallel()
 	ctrl := gomock.NewController(t)
diff --git a/bookback/internal/infrastructure/http/v1/routes/book_router.go b/bookback/internal/infrastructure/http/v1/routes/book_router.go
index a976ba4..2053110 100644
--- a/bookback/internal/infrastructure/http/v1/routes/book_router.go
+++ b/bookback/internal/infrastructure/http/v1/routes/book_router.go
@@ -26,6 +26,8 @@ func Book(e *echo.Echo, database postgres.Client, metrics metrics.Metrics, logge
 	group.POST(v1.ListSubPath, cntr.ListBooks)
 	group.POST("", cntr.CreateBook)
 	group.GET(v1.IDVar, cntr.GetBookByID)
+
+	group.PUT(v1.ToggleSubPath, cntr.TogglePublic)
 	group.PUT(v1.IDVar, cntr.UpdateBook)
 	group.DELETE(v1.IDVar, cntr.DeleteBook)
 }
diff --git a/bookback/internal/infrastructure/http/v1/routes/bookevents_router.go b/bookback/internal/infrastructure/http/v1/routes/bookevents_router.go
index 88f4e21..fbd793e 100644
--- a/bookback/internal/infrastructure/http/v1/routes/bookevents_router.go
+++ b/bookback/internal/infrastructure/http/v1/routes/bookevents_router.go
@@ -21,10 +21,11 @@ func BookEvent(e *echo.Echo, database postgres.Client, metrics metrics.Metrics,
 	group := e.Group(v1.BookEventsPath)
 	group.Use(middleware.MetricsLogger(metrics))
 
-	group.POST("", cntr.CreateBookEvent)
 	group.GET(v1.IDVar, cntr.GetBookEventByID)
+	group.PUT(v1.ToggleSubPath, cntr.TogglePublic)
 	group.PUT(v1.IDVar, cntr.UpdateBookEvent)
 	group.DELETE(v1.IDVar, cntr.DeleteBookEvent)
+	group.POST("", cntr.CreateBookEvent)
 	group.POST(v1.BookSubPath+v1.IDVar, cntr.GetBookEventsByBookID)
 	group.POST(v1.ChapterSubPath+v1.IDVar, cntr.GetBookEventsByChapterID)
 	group.POST("/page"+v1.IDVar, cntr.GetBookEventsByPageID)
diff --git a/bookback/internal/infrastructure/http/v1/routes/chapter_router.go b/bookback/internal/infrastructure/http/v1/routes/chapter_router.go
index 6d64878..60211e2 100644
--- a/bookback/internal/infrastructure/http/v1/routes/chapter_router.go
+++ b/bookback/internal/infrastructure/http/v1/routes/chapter_router.go
@@ -22,9 +22,11 @@ func Chapter(e *echo.Echo, database postgres.Client, metrics metrics.Metrics, lo
 	group.Use(middleware.MetricsLogger(metrics))
 
 	group.POST(v1.ListSubPath, cnt.ListChapters)
+	group.POST("/book"+v1.IDVar, cnt.GetChapterByBookID)
 	group.POST("", cnt.CreateChapter)
+
 	group.GET(v1.IDVar, cnt.GetChapterByID)
+	group.PUT(v1.ToggleSubPath, cnt.TogglePublic)
 	group.PUT(v1.IDVar, cnt.UpdateChapter)
 	group.DELETE(v1.IDVar, cnt.DeleteChapter)
-	group.POST("/book"+v1.IDVar, cnt.GetChapterByBookID)
 }
diff --git a/bookback/internal/infrastructure/http/v1/routes/page_router.go b/bookback/internal/infrastructure/http/v1/routes/page_router.go
index 1951ce7..305a349 100644
--- a/bookback/internal/infrastructure/http/v1/routes/page_router.go
+++ b/bookback/internal/infrastructure/http/v1/routes/page_router.go
@@ -22,9 +22,10 @@ func Page(e *echo.Echo, database postgres.Client, metrics metrics.Metrics, logge
 	group.Use(middleware.MetricsLogger(metrics))
 
 	group.POST(v1.ListSubPath, cnt.ListPages)
+	group.POST("/chapters"+v1.IDVar, cnt.GetPagesByChapterID)
 	group.POST("", cnt.CreatePage)
 	group.GET(v1.IDVar, cnt.GetPageByID)
 	group.PUT(v1.IDVar, cnt.UpdatePage)
+	group.PUT(v1.ToggleSubPath, cnt.TogglePublic)
 	group.DELETE(v1.IDVar, cnt.DeletePage)
-	group.POST("/chapters"+v1.IDVar, cnt.GetPagesByChapterID)
 }
diff --git a/bookback/internal/infrastructure/http/v1/routes/paragraph_router.go b/bookback/internal/infrastructure/http/v1/routes/paragraph_router.go
index 015af39..5df2e3d 100644
--- a/bookback/internal/infrastructure/http/v1/routes/paragraph_router.go
+++ b/bookback/internal/infrastructure/http/v1/routes/paragraph_router.go
@@ -23,8 +23,9 @@ func Paragraph(e *echo.Echo, database postgres.Client, metrics metrics.Metrics,
 
 	group.POST(v1.ListSubPath, cnt.ListParagraphs)
 	group.POST("", cnt.CreateParagraph)
+	group.POST("/pages"+v1.IDVar, cnt.GetParagraphsByPageID)
 	group.GET(v1.IDVar, cnt.GetParagraphByID)
 	group.PUT(v1.IDVar, cnt.UpdateParagraph)
+	group.PUT(v1.ToggleSubPath, cnt.TogglePublic)
 	group.DELETE(v1.IDVar, cnt.DeleteParagraph)
-	group.POST("/pages"+v1.IDVar, cnt.GetParagraphsByPageID)
 }
diff --git a/bookback/internal/models/book_model.go b/bookback/internal/models/book_model.go
index 7bef502..d37fbf1 100644
--- a/bookback/internal/models/book_model.go
+++ b/bookback/internal/models/book_model.go
@@ -28,6 +28,10 @@ type UpdateBookRequest struct {
 	Book *Book `json:"book"`
 }
 
+type ToggleBookRequest struct {
+	BookID string `json:"book_id"`
+}
+
 type RequestBook struct {
 	Options PageOptions `json:"options"`
 	Book    *Book       `json:"book,omitempty"`
diff --git a/bookback/internal/models/bookevents_model.go b/bookback/internal/models/bookevents_model.go
index 5e770cc..a51782e 100644
--- a/bookback/internal/models/bookevents_model.go
+++ b/bookback/internal/models/bookevents_model.go
@@ -30,6 +30,9 @@ type CreateBookEventRequest struct {
 type UpdateBookEventRequest struct {
 	BookEvent *BookEvent `json:"book_event"`
 }
+type ToggleBookEventRequest struct {
+	BookEventID string `json:"book_event_id"`
+}
 
 type RequestBookEvent struct {
 	Options   PageOptions `json:"options,omitempty"`
diff --git a/bookback/internal/models/chapter_model.go b/bookback/internal/models/chapter_model.go
index 421c9c4..4eb0968 100644
--- a/bookback/internal/models/chapter_model.go
+++ b/bookback/internal/models/chapter_model.go
@@ -27,6 +27,10 @@ type UpdateChapterRequest struct {
 	Chapter *Chapter `json:"chapter"`
 }
 
+type ToggleChapterRequest struct {
+	ChapterID string `json:"chapter_id"`
+}
+
 type RequestChapter struct {
 	Options PageOptions `json:"options,omitempty"`
 	Chapter *Chapter    `json:"chapter,omitempty"`
diff --git a/bookback/internal/models/page_model.go b/bookback/internal/models/page_model.go
index 9017ed9..4b22c29 100644
--- a/bookback/internal/models/page_model.go
+++ b/bookback/internal/models/page_model.go
@@ -25,6 +25,10 @@ type UpdatePageRequest struct {
 	Page *Page `json:"page"`
 }
 
+type TogglePageRequest struct {
+	PageID string `json:"page_id"`
+}
+
 type RequestPage struct {
 	Options PageOptions `json:"options,omitempty"`
 	Page    *Page       `json:"page,omitempty"`
diff --git a/bookback/internal/models/paragraph_model.go b/bookback/internal/models/paragraph_model.go
index 0ceb287..50bf01c 100644
--- a/bookback/internal/models/paragraph_model.go
+++ b/bookback/internal/models/paragraph_model.go
@@ -25,6 +25,10 @@ type UpdateParagraphRequest struct {
 	Paragraph *Paragraph `json:"paragraph"`
 }
 
+type ToggleParagraphRequest struct {
+	ParagraphID string `json:"paragraph_id"`
+}
+
 type RequestParagraph struct {
 	Options   PageOptions `json:"options,omitempty"`
 	Paragraph *Paragraph  `json:"paragraph,omitempty"`
diff --git a/bookback/tests/mocks/domain/services/book_service_mock.go b/bookback/tests/mocks/domain/services/book_service_mock.go
index e228ac6..86a3e4a 100644
--- a/bookback/tests/mocks/domain/services/book_service_mock.go
+++ b/bookback/tests/mocks/domain/services/book_service_mock.go
@@ -115,6 +115,21 @@ func (mr *MockBookServiceMockRecorder) ListBooks(arg0, arg1 any) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBooks", reflect.TypeOf((*MockBookService)(nil).ListBooks), arg0, arg1)
 }
 
+// TogglePublic mocks base method.
+func (m *MockBookService) TogglePublic(arg0 context.Context, arg1 models.ToggleBookRequest) (*models.Book, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TogglePublic", arg0, arg1)
+	ret0, _ := ret[0].(*models.Book)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TogglePublic indicates an expected call of TogglePublic.
+func (mr *MockBookServiceMockRecorder) TogglePublic(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TogglePublic", reflect.TypeOf((*MockBookService)(nil).TogglePublic), arg0, arg1)
+}
+
 // UpdateBook mocks base method.
 func (m *MockBookService) UpdateBook(arg0 context.Context, arg1 string, arg2 models.UpdateBookRequest) (*models.Book, error) {
 	m.ctrl.T.Helper()
diff --git a/bookback/tests/mocks/domain/services/bookevents_service_mock.go b/bookback/tests/mocks/domain/services/bookevents_service_mock.go
index 22b3342..0aacc4e 100644
--- a/bookback/tests/mocks/domain/services/bookevents_service_mock.go
+++ b/bookback/tests/mocks/domain/services/bookevents_service_mock.go
@@ -145,6 +145,21 @@ func (mr *MockBookEventsServiceMockRecorder) GetBookEventsByParagraphID(arg0, ar
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBookEventsByParagraphID", reflect.TypeOf((*MockBookEventsService)(nil).GetBookEventsByParagraphID), arg0, arg1, arg2)
 }
 
+// TogglePublic mocks base method.
+func (m *MockBookEventsService) TogglePublic(arg0 context.Context, arg1 models.ToggleBookEventRequest) (*models.BookEvent, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TogglePublic", arg0, arg1)
+	ret0, _ := ret[0].(*models.BookEvent)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TogglePublic indicates an expected call of TogglePublic.
+func (mr *MockBookEventsServiceMockRecorder) TogglePublic(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TogglePublic", reflect.TypeOf((*MockBookEventsService)(nil).TogglePublic), arg0, arg1)
+}
+
 // UpdateBookEvent mocks base method.
 func (m *MockBookEventsService) UpdateBookEvent(arg0 context.Context, arg1 string, arg2 models.UpdateBookEventRequest) (*models.BookEvent, error) {
 	m.ctrl.T.Helper()
diff --git a/bookback/tests/mocks/domain/services/chapter_service_mock.go b/bookback/tests/mocks/domain/services/chapter_service_mock.go
index 4a89b0f..a2f8f91 100644
--- a/bookback/tests/mocks/domain/services/chapter_service_mock.go
+++ b/bookback/tests/mocks/domain/services/chapter_service_mock.go
@@ -115,6 +115,21 @@ func (mr *MockChapterServiceMockRecorder) ListChapters(arg0, arg1 any) *gomock.C
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChapters", reflect.TypeOf((*MockChapterService)(nil).ListChapters), arg0, arg1)
 }
 
+// TogglePublic mocks base method.
+func (m *MockChapterService) TogglePublic(arg0 context.Context, arg1 models.ToggleChapterRequest) (*models.Chapter, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TogglePublic", arg0, arg1)
+	ret0, _ := ret[0].(*models.Chapter)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TogglePublic indicates an expected call of TogglePublic.
+func (mr *MockChapterServiceMockRecorder) TogglePublic(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TogglePublic", reflect.TypeOf((*MockChapterService)(nil).TogglePublic), arg0, arg1)
+}
+
 // UpdateChapter mocks base method.
 func (m *MockChapterService) UpdateChapter(arg0 context.Context, arg1 string, arg2 models.UpdateChapterRequest) (*models.Chapter, error) {
 	m.ctrl.T.Helper()
diff --git a/bookback/tests/mocks/domain/services/page_service_mock.go b/bookback/tests/mocks/domain/services/page_service_mock.go
index 0698f51..e4b1afb 100644
--- a/bookback/tests/mocks/domain/services/page_service_mock.go
+++ b/bookback/tests/mocks/domain/services/page_service_mock.go
@@ -115,6 +115,21 @@ func (mr *MockPageServiceMockRecorder) ListPages(arg0, arg1 any) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPages", reflect.TypeOf((*MockPageService)(nil).ListPages), arg0, arg1)
 }
 
+// TogglePublic mocks base method.
+func (m *MockPageService) TogglePublic(arg0 context.Context, arg1 models.TogglePageRequest) (*models.Page, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TogglePublic", arg0, arg1)
+	ret0, _ := ret[0].(*models.Page)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TogglePublic indicates an expected call of TogglePublic.
+func (mr *MockPageServiceMockRecorder) TogglePublic(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TogglePublic", reflect.TypeOf((*MockPageService)(nil).TogglePublic), arg0, arg1)
+}
+
 // UpdatePage mocks base method.
 func (m *MockPageService) UpdatePage(arg0 context.Context, arg1 string, arg2 models.UpdatePageRequest) (*models.Page, error) {
 	m.ctrl.T.Helper()
diff --git a/bookback/tests/mocks/domain/services/paragraph_service_mock.go b/bookback/tests/mocks/domain/services/paragraph_service_mock.go
index 40f44a7..d252311 100644
--- a/bookback/tests/mocks/domain/services/paragraph_service_mock.go
+++ b/bookback/tests/mocks/domain/services/paragraph_service_mock.go
@@ -115,6 +115,21 @@ func (mr *MockParagraphServiceMockRecorder) ListParagraphs(arg0, arg1 any) *gomo
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListParagraphs", reflect.TypeOf((*MockParagraphService)(nil).ListParagraphs), arg0, arg1)
 }
 
+// TogglePublic mocks base method.
+func (m *MockParagraphService) TogglePublic(arg0 context.Context, arg1 models.ToggleParagraphRequest) (*models.Paragraph, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TogglePublic", arg0, arg1)
+	ret0, _ := ret[0].(*models.Paragraph)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TogglePublic indicates an expected call of TogglePublic.
+func (mr *MockParagraphServiceMockRecorder) TogglePublic(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TogglePublic", reflect.TypeOf((*MockParagraphService)(nil).TogglePublic), arg0, arg1)
+}
+
 // UpdateParagraph mocks base method.
 func (m *MockParagraphService) UpdateParagraph(arg0 context.Context, arg1 string, arg2 models.UpdateParagraphRequest) (*models.Paragraph, error) {
 	m.ctrl.T.Helper()