diff --git a/CHANGELOG.md b/CHANGELOG.md
index 27fe6d0b..b319f158 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- new command `split` to allow break a time entry into others with break points
+
 ## [v0.51.1] - 2024-05-30
 
 ### Fixed
diff --git a/pkg/cmd/time-entry/edit/edit.go b/pkg/cmd/time-entry/edit/edit.go
index cbc798ee..4436bbc2 100644
--- a/pkg/cmd/time-entry/edit/edit.go
+++ b/pkg/cmd/time-entry/edit/edit.go
@@ -149,11 +149,7 @@ func NewCmdEdit(
 				return err
 			}
 
-			if report != nil {
-				return report(tei, cmd.OutOrStdout(), of)
-			}
-
-			return util.PrintTimeEntryImpl(tei, f, cmd.OutOrStdout(), of)
+			return report(tei, cmd.OutOrStdout(), of)
 		},
 	}
 
diff --git a/pkg/cmd/time-entry/in/in.go b/pkg/cmd/time-entry/in/in.go
index a57c6c4b..0e5f1d40 100644
--- a/pkg/cmd/time-entry/in/in.go
+++ b/pkg/cmd/time-entry/in/in.go
@@ -136,13 +136,8 @@ func NewCmdIn(
 				return err
 			}
 
-			if report != nil {
-				return report(
-					util.TimeEntryDTOToImpl(tei), cmd.OutOrStdout(), of)
-			}
-
-			return util.PrintTimeEntryImpl(
-				util.TimeEntryDTOToImpl(tei), f, cmd.OutOrStdout(), of)
+			return report(
+				util.TimeEntryDTOToImpl(tei), cmd.OutOrStdout(), of)
 		},
 	}
 
diff --git a/pkg/cmd/time-entry/split/split.go b/pkg/cmd/time-entry/split/split.go
new file mode 100644
index 00000000..574c9980
--- /dev/null
+++ b/pkg/cmd/time-entry/split/split.go
@@ -0,0 +1,206 @@
+package split
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/MakeNowJust/heredoc"
+	"github.com/lucassabreu/clockify-cli/api"
+	"github.com/lucassabreu/clockify-cli/api/dto"
+	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/util"
+	"github.com/lucassabreu/clockify-cli/pkg/cmdcompl"
+	"github.com/lucassabreu/clockify-cli/pkg/cmdutil"
+	"github.com/lucassabreu/clockify-cli/pkg/timeentryhlp"
+	"github.com/lucassabreu/clockify-cli/pkg/timehlp"
+	"github.com/spf13/cobra"
+	"golang.org/x/sync/errgroup"
+)
+
+func NewCmdSplit(
+	f cmdutil.Factory,
+	report func([]dto.TimeEntry, io.Writer, util.OutputFlags) error,
+) *cobra.Command {
+	of := util.OutputFlags{TimeFormat: timehlp.OnlyTimeFormat}
+	va := cmdcompl.ValidArgsSlide{
+		timeentryhlp.AliasCurrent,
+		timeentryhlp.AliasLast,
+		timeentryhlp.AliasLatest,
+	}
+
+	cmd := &cobra.Command{
+		Use: "split { <time-entry-id> | " + va.IntoUseOptions() + " | ^n } " +
+			" <time>...",
+		Args: cobra.MatchAll(
+			cmdutil.RequiredNamedArgs("time entry id"),
+			cobra.MinimumNArgs(2),
+		),
+		ValidArgs: va.IntoValidArgs(),
+		Short:     `Splits a time entry into multiple time entries`,
+		Long: heredoc.Docf(`
+			Split a time entry.
+			The time arguments can be more than one, but must be increasing.
+
+			%s
+			%s
+			%s
+			%s
+			%s
+		`,
+			util.HelpTimeEntriesAliasForEdit,
+			util.HelpInteractiveByDefault,
+			util.HelpDateTimeFormats,
+			util.HelpNamesForIds,
+			util.HelpMoreInfoAboutPrinting,
+		),
+		Example: heredoc.Docf(`
+			# starting a time entry
+			$ %[1]s in --project cli --tag dev -d "Doing work before lunch" --task "edit" --md
+			ID: %[2]s62ae4b304ebb4f143c931d50%[2]s  
+			Billable: %[2]syes%[2]s  
+			Locked: %[2]sno%[2]s  
+			Project: Clockify Cli (%[2]s621948458cb9606d934ebb1c%[2]s)  
+			Task: Edit Command (%[2]s62ae4af04ebb4f143c931d2e%[2]s)  
+			Interval: %[2]s2022-06-18 11:01:16%[2]s until %[2]snow%[2]s  
+			Description:
+			> Adding docs to edit
+
+			Tags:
+			 * Development (%[2]s62ae28b72518aa18da2acb49%[2]s)
+
+			# splits the time entry at lunch and now
+			$ %[1]s split 12:00 13:30 --format '{{.ID}},{{.TimeInterval.Start|ft}}'
+			62ae4b304ebb4f143c931d50,11:01
+			3c931d502ae4b3064ebb4f14,12:00
+			ebb4f143c962ae4b30431d50,13:30
+		`, "clockify-cli", "`"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := of.Check(); err != nil {
+				return err
+			}
+
+			splits := make([]time.Time, len(args)-1)
+			for i := range splits {
+				t, err := timehlp.ConvertToTime(args[1+i])
+				if err != nil {
+					return fmt.Errorf(
+						"argument %d could not be converted to time: %w",
+						i+2, err)
+				}
+
+				if i > 0 && t.Before(splits[i-1]) {
+					return errors.New("splits must be in increasing order")
+				}
+
+				splits[i] = t
+			}
+
+			c, err := f.Client()
+			if err != nil {
+				return err
+			}
+
+			userID, err := f.GetUserID()
+			if err != nil {
+				return err
+			}
+
+			w, err := f.GetWorkspaceID()
+			if err != nil {
+				return err
+			}
+
+			te, err := timeentryhlp.GetTimeEntry(
+				c,
+				w,
+				userID,
+				args[0],
+			)
+			if err != nil {
+				return err
+			}
+
+			if te.TimeInterval.Start.After(splits[0]) {
+				return errors.New("time splits must be after " +
+					te.TimeInterval.Start.Format(timehlp.FullTimeFormat))
+			}
+
+			if te.TimeInterval.End != nil && te.TimeInterval.End.Before(
+				splits[len(splits)-1]) {
+				return errors.New("time splits must be before " +
+					te.TimeInterval.End.Format(timehlp.FullTimeFormat))
+			}
+
+			if _, err = c.UpdateTimeEntry(api.UpdateTimeEntryParam{
+				Workspace:   te.WorkspaceID,
+				TimeEntryID: te.ID,
+				Description: te.Description,
+				Start:       te.TimeInterval.Start,
+				End:         &splits[0],
+				Billable:    te.Billable,
+				ProjectID:   te.ProjectID,
+				TaskID:      te.TaskID,
+				TagIDs:      te.TagIDs,
+			}); err != nil {
+				return err
+			}
+
+			tes := make([]dto.TimeEntry, len(splits)+1)
+			getHydrated := func(i int, id string) error {
+				t, err := c.GetHydratedTimeEntry(api.GetTimeEntryParam{
+					TimeEntryID: id,
+					Workspace:   w,
+				})
+
+				if err != nil {
+					return err
+				}
+				tes[i] = *t
+				return nil
+			}
+
+			eg := errgroup.Group{}
+			eg.Go(func() error { return getHydrated(0, te.ID) })
+
+			for i := range splits {
+				i := i
+				eg.Go(func() error {
+					end := te.TimeInterval.End
+					if i < len(splits)-1 {
+						end = &splits[i+1]
+					}
+
+					te, err := c.CreateTimeEntry(api.CreateTimeEntryParam{
+						Workspace:   te.WorkspaceID,
+						Billable:    &te.Billable,
+						Start:       splits[i],
+						End:         end,
+						ProjectID:   te.ProjectID,
+						Description: te.Description,
+						TagIDs:      te.TagIDs,
+						TaskID:      te.TaskID,
+					})
+
+					if err != nil {
+						return err
+					}
+
+					return getHydrated(i+1, te.ID)
+				})
+
+			}
+
+			if err := eg.Wait(); err != nil {
+				return err
+			}
+
+			return report(tes, cmd.OutOrStdout(), of)
+		},
+	}
+
+	util.AddPrintTimeEntriesFlags(cmd, &of)
+	util.AddPrintMultipleTimeEntriesFlags(cmd)
+
+	return cmd
+}
diff --git a/pkg/cmd/time-entry/split/split_test.go b/pkg/cmd/time-entry/split/split_test.go
new file mode 100644
index 00000000..b87568b0
--- /dev/null
+++ b/pkg/cmd/time-entry/split/split_test.go
@@ -0,0 +1,350 @@
+package split_test
+
+import (
+	"bytes"
+	"io"
+	"testing"
+	"time"
+
+	"github.com/lucassabreu/clockify-cli/api"
+	"github.com/lucassabreu/clockify-cli/api/dto"
+	"github.com/lucassabreu/clockify-cli/internal/mocks"
+	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/split"
+	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/util"
+	"github.com/lucassabreu/clockify-cli/pkg/cmdutil"
+	"github.com/lucassabreu/clockify-cli/pkg/timehlp"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewCmdSplitShouldFail(t *testing.T) {
+	w := dto.Workspace{ID: "w"}
+	start, _ := timehlp.ConvertToTime("2024-06-02 08:15")
+	end, _ := timehlp.ConvertToTime("2024-06-02 12:15")
+	te := dto.TimeEntryImpl{
+		WorkspaceID: w.ID,
+		ID:          "timeentryid",
+		Description: "Something",
+		ProjectID:   "oldproj",
+		TaskID:      "oldtask",
+		TimeInterval: dto.TimeInterval{
+			Start: start,
+			End:   &end,
+		},
+	}
+
+	findTT := func(t *testing.T) cmdutil.Factory {
+		f := mocks.NewMockFactory(t)
+
+		f.EXPECT().GetWorkspaceID().Return(w.ID, nil)
+		f.EXPECT().GetUserID().Return(w.ID, nil)
+
+		c := mocks.NewMockClient(t)
+		f.EXPECT().Client().Return(c, nil)
+
+		c.EXPECT().GetTimeEntry(api.GetTimeEntryParam{
+			Workspace:   te.WorkspaceID,
+			TimeEntryID: te.ID,
+		}).
+			Return(&te, nil)
+
+		return f
+	}
+
+	tts := []struct {
+		name string
+		args []string
+		f    func(*testing.T) cmdutil.Factory
+		err  string
+	}{
+		{
+			name: "time string is not valid",
+			f: func(t *testing.T) cmdutil.Factory {
+				return mocks.NewMockFactory(t)
+			},
+			args: []string{te.ID, "ff"},
+			err:  "argument 2 could not be converted",
+		},
+		{
+			name: "third time string is not valid",
+			f: func(t *testing.T) cmdutil.Factory {
+				return mocks.NewMockFactory(t)
+			},
+			args: []string{te.ID, "11:00", "ff"},
+			err:  "argument 3 could not be converted",
+		},
+		{
+			name: "split must be in order",
+			f: func(t *testing.T) cmdutil.Factory {
+				return mocks.NewMockFactory(t)
+			},
+			args: []string{te.ID, "8:30", "08:20"},
+			err:  "splits must be in increasing order",
+		},
+		{
+			name: "time entry not found",
+			f: func(t *testing.T) cmdutil.Factory {
+				f := mocks.NewMockFactory(t)
+
+				f.EXPECT().GetWorkspaceID().Return(w.ID, nil)
+				f.EXPECT().GetUserID().Return(w.ID, nil)
+
+				c := mocks.NewMockClient(t)
+				f.EXPECT().Client().Return(c, nil)
+
+				c.EXPECT().GetTimeEntry(api.GetTimeEntryParam{
+					Workspace:   te.WorkspaceID,
+					TimeEntryID: te.ID,
+				}).
+					Return(nil, nil)
+
+				return f
+			},
+			args: []string{te.ID, "11:00"},
+			err:  "not found",
+		},
+		{
+			name: "split must be after the time entry start",
+			f:    findTT,
+			args: []string{te.ID, "7:00"},
+			err:  "time splits must be after 2024-06-02 08:15",
+		},
+		{
+			name: "split must be before the time entry ends",
+			f:    findTT,
+			args: []string{te.ID, "18:00"},
+			err:  "time splits must be before 2024-06-02 12:15",
+		},
+	}
+
+	for i := range tts {
+		tt := &tts[i]
+		t.Run(tt.name, func(t *testing.T) {
+			called := false
+			cmd := split.NewCmdSplit(tt.f(t), func(
+				_ []dto.TimeEntry, _ io.Writer, _ util.OutputFlags) error {
+				called = true
+				return nil
+			})
+
+			cmd.SilenceUsage = true
+			cmd.SilenceErrors = true
+
+			out := bytes.NewBufferString("")
+			cmd.SetOut(out)
+			cmd.SetErr(out)
+
+			cmd.SetArgs(tt.args)
+			_, err := cmd.ExecuteC()
+
+			assert.False(t, called)
+			assert.Error(t, err)
+			assert.Regexp(t, tt.err, err.Error())
+		})
+	}
+}
+
+func TestNewCmdSplitShouldCreateNewEntries(t *testing.T) {
+	w := dto.Workspace{ID: "w"}
+	start, _ := timehlp.ConvertToTime("2024-06-02 08:00")
+	te := dto.TimeEntryImpl{
+		WorkspaceID: w.ID,
+		ID:          "timeentryid",
+		Description: "Something",
+		ProjectID:   "oldproj",
+		TaskID:      "oldtask",
+		TimeInterval: dto.TimeInterval{
+			Start: start,
+		},
+	}
+
+	getH := func(c *mocks.MockClient, id string) {
+
+		c.EXPECT().GetHydratedTimeEntry(api.GetTimeEntryParam{
+			Workspace:   w.ID,
+			TimeEntryID: id,
+		}).
+			Return(&dto.TimeEntry{
+				WorkspaceID: te.WorkspaceID,
+				ID:          id,
+			}, nil)
+	}
+
+	getAndUpdate := func(
+		t *testing.T, te dto.TimeEntryImpl, end time.Time,
+	) (cmdutil.Factory, *mocks.MockClient) {
+		f := mocks.NewMockFactory(t)
+
+		f.EXPECT().GetWorkspaceID().Return(w.ID, nil)
+		f.EXPECT().GetUserID().Return(w.ID, nil)
+
+		c := mocks.NewMockClient(t)
+		f.EXPECT().Client().Return(c, nil)
+
+		c.EXPECT().GetTimeEntry(api.GetTimeEntryParam{
+			Workspace:   te.WorkspaceID,
+			TimeEntryID: te.ID,
+		}).
+			Return(&te, nil)
+
+		c.EXPECT().UpdateTimeEntry(api.UpdateTimeEntryParam{
+			Workspace:   te.WorkspaceID,
+			TimeEntryID: te.ID,
+			Start:       te.TimeInterval.Start,
+			End:         &end,
+			Billable:    false,
+			Description: te.Description,
+			ProjectID:   te.ProjectID,
+			TaskID:      te.TaskID,
+			TagIDs:      te.TagIDs,
+		}).
+			Return(te, nil)
+
+		getH(c, te.ID)
+
+		return f, c
+	}
+
+	create := func(c *mocks.MockClient, id string, ted util.TimeEntryDTO) {
+		c.EXPECT().CreateTimeEntry(api.CreateTimeEntryParam{
+			Workspace:   te.WorkspaceID,
+			Start:       ted.Start,
+			End:         ted.End,
+			Description: te.Description,
+			ProjectID:   te.ProjectID,
+			TaskID:      te.TaskID,
+			TagIDs:      te.TagIDs,
+			Billable:    &te.Billable,
+		}).
+			Return(dto.TimeEntryImpl{ID: id}, nil)
+
+		getH(c, id)
+	}
+
+	tts := []struct {
+		name string
+		args []string
+		f    func(*testing.T) cmdutil.Factory
+	}{
+		{
+			name: "split in two",
+			args: []string{te.ID, "8:30"},
+			f: func(t *testing.T) cmdutil.Factory {
+				s, _ := timehlp.ConvertToTime("2024-06-02 08:30")
+				f, c := getAndUpdate(t, te, s)
+
+				create(c, "123", util.TimeEntryDTO{
+					Workspace:   te.ID,
+					UserID:      te.UserID,
+					ProjectID:   te.ProjectID,
+					TaskID:      te.TaskID,
+					Description: te.Description,
+					Start:       s,
+					End:         nil,
+				})
+
+				return f
+			},
+		},
+		{
+			name: "split in three",
+			args: []string{te.ID, "08:20", "8:30"},
+			f: func(t *testing.T) cmdutil.Factory {
+				s, _ := timehlp.ConvertToTime("2024-06-02 08:20")
+				f, c := getAndUpdate(t, te, s)
+
+				e, _ := timehlp.ConvertToTime("2024-06-02 08:30")
+				create(c, "123", util.TimeEntryDTO{
+					Workspace:   te.ID,
+					UserID:      te.UserID,
+					ProjectID:   te.ProjectID,
+					TaskID:      te.TaskID,
+					Description: te.Description,
+					Start:       s,
+					End:         &e,
+				})
+
+				create(c, "456", util.TimeEntryDTO{
+					Workspace:   te.ID,
+					UserID:      te.UserID,
+					ProjectID:   te.ProjectID,
+					TaskID:      te.TaskID,
+					Description: te.Description,
+					Start:       e,
+					End:         nil,
+				})
+
+				return f
+			},
+		},
+		{
+			name: "split in three with end",
+			args: []string{te.ID, "08:30", "9:00"},
+			f: func(t *testing.T) cmdutil.Factory {
+				end, _ := timehlp.ConvertToTime("2024-06-02 10:00")
+				te := dto.TimeEntryImpl{
+					WorkspaceID: w.ID,
+					ID:          "timeentryid",
+					Description: "Something",
+					ProjectID:   "oldproj",
+					TaskID:      "oldtask",
+					TimeInterval: dto.NewTimeInterval(
+						te.TimeInterval.Start,
+						&end,
+					),
+				}
+
+				s, _ := timehlp.ConvertToTime("2024-06-02 08:30")
+				f, c := getAndUpdate(t, te, s)
+
+				e, _ := timehlp.ConvertToTime("2024-06-02 09:00")
+				create(c, "123", util.TimeEntryDTO{
+					Workspace:   te.ID,
+					UserID:      te.UserID,
+					ProjectID:   te.ProjectID,
+					TaskID:      te.TaskID,
+					Description: te.Description,
+					Start:       s,
+					End:         &e,
+				})
+
+				create(c, "456", util.TimeEntryDTO{
+					Workspace:   te.ID,
+					UserID:      te.UserID,
+					ProjectID:   te.ProjectID,
+					TaskID:      te.TaskID,
+					Description: te.Description,
+					Start:       e,
+					End:         &end,
+				})
+
+				return f
+			},
+		},
+	}
+
+	for i := range tts {
+		tt := &tts[i]
+		t.Run(tt.name, func(t *testing.T) {
+			called := false
+			cmd := split.NewCmdSplit(tt.f(t), func(
+				_ []dto.TimeEntry, _ io.Writer, _ util.OutputFlags) error {
+				called = true
+				return nil
+			})
+
+			cmd.SilenceUsage = true
+			cmd.SilenceErrors = true
+
+			out := bytes.NewBufferString("")
+			cmd.SetOut(out)
+			cmd.SetErr(out)
+
+			cmd.SetArgs(tt.args)
+			_, err := cmd.ExecuteC()
+
+			if assert.True(t, called) || assert.NoError(t, err) {
+				return
+			}
+		})
+	}
+}
diff --git a/pkg/cmd/time-entry/timeentry.go b/pkg/cmd/time-entry/timeentry.go
index 475e923e..ba5d7ef1 100644
--- a/pkg/cmd/time-entry/timeentry.go
+++ b/pkg/cmd/time-entry/timeentry.go
@@ -1,6 +1,9 @@
 package timeentry
 
 import (
+	"io"
+
+	"github.com/lucassabreu/clockify-cli/api/dto"
 	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/clone"
 	del "github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/delete"
 	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/edit"
@@ -11,21 +14,36 @@ import (
 	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/out"
 	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/report"
 	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/show"
+	"github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/split"
+	teutil "github.com/lucassabreu/clockify-cli/pkg/cmd/time-entry/util"
 	"github.com/lucassabreu/clockify-cli/pkg/cmdutil"
 	"github.com/spf13/cobra"
 )
 
 func NewCmdTimeEntry(f cmdutil.Factory) (cmds []*cobra.Command) {
+	rmFn := func(
+		tes []dto.TimeEntry, out io.Writer, of teutil.OutputFlags) error {
+		return teutil.PrintTimeEntries(tes, out, f.Config(), of)
+	}
+
+	rFn := func(
+		tei dto.TimeEntryImpl, out io.Writer, of teutil.OutputFlags,
+	) error {
+		return teutil.PrintTimeEntryImpl(tei, f, out, of)
+	}
+
 	cmds = append(
 		cmds,
 
-		in.NewCmdIn(f, nil),
+		in.NewCmdIn(f, rFn),
 		manual.NewCmdManual(f),
 		clone.NewCmdClone(f),
 
-		edit.NewCmdEdit(f, nil),
+		edit.NewCmdEdit(f, rFn),
 		em.NewCmdEditMultiple(f),
 
+		split.NewCmdSplit(f, rmFn),
+
 		out.NewCmdOut(f),
 
 		del.NewCmdDelete(f),