diff --git a/client/api/events.ts b/client/api/events.ts
index 6f0968ef9..fb029428c 100644
--- a/client/api/events.ts
+++ b/client/api/events.ts
@@ -6,6 +6,7 @@ import {
     ISearchParams,
     ISearchSpikeState,
     IPlanningConfig,
+    IEventUpdateMethod,
 } from '../interfaces';
 import {appConfig as config} from 'appConfig';
 import {IRestApiResponse} from 'superdesk-api';
@@ -122,14 +123,16 @@ function getEventSearchProfile() {
 }
 
 function create(updates: Partial<IEventItem>): Promise<Array<IEventItem>> {
-    const url = appConfig.planning.default_create_planning_series_with_event_series === true ?
-        'events?add_to_series=true' :
-        'events';
+    const {default_create_planning_series_with_event_series} = appConfig.planning;
+    const planningDefaultCreateMethod: IEventUpdateMethod = default_create_planning_series_with_event_series === true ?
+        'all' :
+        'single';
 
-    return superdeskApi.dataApi.create<IEventItem | IRestApiResponse<IEventItem>>(url, {
+    return superdeskApi.dataApi.create<IEventItem | IRestApiResponse<IEventItem>>('events', {
         ...updates,
         associated_plannings: undefined,
         embedded_planning: updates.associated_plannings.map((planning) => ({
+            update_method: planning.update_method ?? planningDefaultCreateMethod,
             coverages: planning.coverages.map((coverage) => ({
                 coverage_id: coverage.coverage_id,
                 g2_content_type: coverage.planning.g2_content_type,
@@ -142,6 +145,7 @@ function create(updates: Partial<IEventItem>): Promise<Array<IEventItem>> {
                 slugline: coverage.planning.slugline,
                 ednote: coverage.planning.ednote,
                 internal_note: coverage.planning.internal_note,
+                headline: coverage.planning.headline,
             })),
         })),
         update_method: updates.update_method?.value ?? updates.update_method
diff --git a/client/api/planning.ts b/client/api/planning.ts
index 1a6dfffa8..477352ea8 100644
--- a/client/api/planning.ts
+++ b/client/api/planning.ts
@@ -145,11 +145,8 @@ function getPlanningSearchProfile() {
     return planningSearchProfile(planningApi.redux.store.getState());
 }
 
-function create(updates: Partial<IPlanningItem>, addToSeries?: boolean): Promise<IPlanningItem> {
-    return superdeskApi.dataApi.create<IPlanningItem>(
-        addToSeries === true ? 'planning?add_to_series=true' : 'planning',
-        updates
-    );
+function create(updates: Partial<IPlanningItem>): Promise<IPlanningItem> {
+    return superdeskApi.dataApi.create<IPlanningItem>('planning', updates);
 }
 
 function update(original: IPlanningItem, updates: Partial<IPlanningItem>): Promise<IPlanningItem> {
@@ -161,6 +158,10 @@ function update(original: IPlanningItem, updates: Partial<IPlanningItem>): Promi
 }
 
 function createFromEvent(event: IEventItem, updates: Partial<IPlanningItem>): Promise<IPlanningItem> {
+    if (updates.update_method == null && appConfig.planning.default_create_planning_series_with_event_series === true) {
+        updates.update_method = 'all';
+    }
+
     return create(
         planningUtils.modifyForServer({
             slugline: event.slugline,
@@ -176,7 +177,6 @@ function createFromEvent(event: IEventItem, updates: Partial<IPlanningItem>): Pr
             ...updates,
             event_item: event._id,
         }),
-        appConfig.planning.default_create_planning_series_with_event_series === true,
     );
 }
 
diff --git a/client/components/ItemActionConfirmation/forms/updateRecurringEventsForm.tsx b/client/components/ItemActionConfirmation/forms/updateRecurringEventsForm.tsx
index c7decc026..f167e47f1 100644
--- a/client/components/ItemActionConfirmation/forms/updateRecurringEventsForm.tsx
+++ b/client/components/ItemActionConfirmation/forms/updateRecurringEventsForm.tsx
@@ -52,6 +52,7 @@ interface IState {
     diff: Partial<IEventItem>;
     eventModified: boolean;
     recurringPlanningItemsToUpdate: Array<IPlanningItem['_id']>;
+    recurringPlanningItemsToCreate: Array<IPlanningItem['_id']>;
     planningUpdateMethods: {[planningId: string]: IEventUpdateMethod};
 }
 
@@ -109,6 +110,12 @@ function getRecurringPlanningToUpdate(
         .map((planningItem) => planningItem._id);
 }
 
+function getRecurringPlanningToCreate(updates: Partial<IEventItem>): Array<IPlanningItem['_id']> {
+    return (updates.associated_plannings ?? [])
+        .filter((planningItem) => (planningItem._id.startsWith(TEMP_ID_PREFIX)))
+        .map((planningItem) => planningItem._id);
+}
+
 export class UpdateRecurringEventsComponent extends React.Component<IProps, IState> {
     constructor(props: IProps) {
         super(props);
@@ -143,6 +150,7 @@ export class UpdateRecurringEventsComponent extends React.Component<IProps, ISta
                 this.props.updates,
                 this.props.originalPlanningItems
             ),
+            recurringPlanningItemsToCreate: getRecurringPlanningToCreate(this.props.updates),
             planningUpdateMethods: {},
         };
 
@@ -183,8 +191,41 @@ export class UpdateRecurringEventsComponent extends React.Component<IProps, ISta
         return this.props.onSubmit(this.props.original, updates);
     }
 
+    renderPlanningCreateForm() {
+        if (this.state.recurringPlanningItemsToCreate.length > 0) {
+            return this.props.updates.associated_plannings
+                .filter((planningItem) => (
+                    this.state.recurringPlanningItemsToCreate.includes(planningItem._id)
+                ))
+                .map((planningItem) => (
+                    <div key={planningItem._id}>
+                        <Select
+                            label={gettext('Create planning for all events or just this one?')}
+                            value={this.state.planningUpdateMethods[planningItem._id] ?? EVENTS.UPDATE_METHODS[0].value}
+                            onChange={(updateMethod) => {
+                                this.onPlanningUpdateMethodChange(planningItem._id, updateMethod as IEventUpdateMethod);
+                            }}
+                        >
+                            <Option value={EVENTS.UPDATE_METHODS[0].value}>
+                                {gettext('This event only')}
+                            </Option>
+                            <Option value={EVENTS.UPDATE_METHODS[1].value}>
+                                {gettext('This and all future events')}
+                            </Option>
+                            <Option value={EVENTS.UPDATE_METHODS[2].value}>
+                                {gettext('All Events')}
+                            </Option>
+                        </Select>
+                        <PlanningMetaData plan={planningItem} />
+                    </div>
+                ));
+        }
+
+        return null;
+    }
+
     renderPlanningUpdateForm() {
-        if (Object.keys(this.state.recurringPlanningItemsToUpdate).length > 0) {
+        if (this.state.recurringPlanningItemsToUpdate.length > 0) {
             return this.props.updates.associated_plannings
                 .filter((planningItem) => (
                     this.state.recurringPlanningItemsToUpdate.includes(planningItem._id)
@@ -192,7 +233,7 @@ export class UpdateRecurringEventsComponent extends React.Component<IProps, ISta
                 .map((planningItem) => (
                     <div key={planningItem._id}>
                         <Select
-                            label="Update all recurring planning or just this one?"
+                            label={gettext('Update all recurring planning or just this one?')}
                             value={this.state.planningUpdateMethods[planningItem._id] ?? EVENTS.UPDATE_METHODS[0].value}
                             onChange={(updateMethod) => {
                                 this.onPlanningUpdateMethodChange(planningItem._id, updateMethod as IEventUpdateMethod);
@@ -277,6 +318,7 @@ export class UpdateRecurringEventsComponent extends React.Component<IProps, ISta
                         />
                     </div>
                 )}
+                {this.renderPlanningCreateForm()}
                 {this.renderPlanningUpdateForm()}
             </React.Fragment>
         );
diff --git a/server/features/planning_recurring.feature b/server/features/planning_recurring.feature
index 7351b90a6..bf100b150 100644
--- a/server/features/planning_recurring.feature
+++ b/server/features/planning_recurring.feature
@@ -41,11 +41,12 @@ Feature: Recurring Events & Planning
             "dates": {"start": "2024-11-23T12:00:00+0000", "end": "2024-11-23T14:00:00+0000"}
         }]}
         """
-        When we post to "/planning?add_to_series=true"
+        When we post to "/planning"
         """
         [{
             "event_item": "#EVENT1._id#",
             "planning_date": "2024-11-21T12:00:00.000Z",
+            "update_method": "all",
             "coverages": [{
                 "workflow_status": "draft",
                 "news_coverage_status": {"qcode": "ncostat:int"},
diff --git a/server/features/recurring_event_and_planning.feature b/server/features/recurring_event_and_planning.feature
index ce0bb49f7..012091b0a 100644
--- a/server/features/recurring_event_and_planning.feature
+++ b/server/features/recurring_event_and_planning.feature
@@ -89,14 +89,74 @@ Feature: Recurring Events & Planning
         }]}
         """
 
+    @auth
+    Scenario: Create planning for future events
+        When we post to "/planning"
+        """
+        [{
+            "headline": "test headline",
+            "event_item": "#EVENT2._id#",
+            "planning_date": "2024-11-22T12:00:00.000Z",
+            "update_method": "future",
+            "coverages": [{
+                "workflow_status": "draft",
+                "news_coverage_status": {"qcode": "ncostat:int"},
+                "planning": {
+                    "headline": "test headline",
+                    "slugline": "test slugline",
+                    "g2_content_type": "text",
+                    "scheduled": "2024-11-22T15:00:00.000Z"
+                }
+            }, {
+                "workflow_status": "draft",
+                "news_coverage_status": {"qcode": "ncostat:int"},
+                "planning": {
+                    "headline": "test headline",
+                    "slugline": "test slugline",
+                    "g2_content_type": "picture",
+                    "scheduled": "2024-11-22T16:00:00.000Z"
+                }
+            }]
+        }]
+        """
+        Then we get OK response
+        When we get "/planning"
+        Then we get list with 2 items
+        """
+        {"_items": [{
+            "guid": "__any_value__",
+            "type": "planning",
+            "headline": "test headline",
+            "planning_date": "2024-11-22T12:00:00+0000",
+            "event_item": "#EVENT2._id#",
+            "recurrence_id": "#EVENT1.recurrence_id#",
+            "coverages": [
+                {"planning": {"g2_content_type": "text", "scheduled": "2024-11-22T15:00:00+0000"}},
+                {"planning": {"g2_content_type": "picture", "scheduled": "2024-11-22T16:00:00+0000"}}
+            ]
+        }, {
+            "guid": "__any_value__",
+            "type": "planning",
+            "headline": "test headline",
+            "planning_date": "2024-11-23T12:00:00+0000",
+            "event_item": "#EVENT3._id#",
+            "recurrence_id": "#EVENT1.recurrence_id#",
+            "coverages": [
+                {"planning": {"g2_content_type": "text", "scheduled": "2024-11-23T15:00:00+0000"}},
+                {"planning": {"g2_content_type": "picture", "scheduled": "2024-11-23T16:00:00+0000"}}
+            ]
+        }]}
+        """
+
     @auth
     Scenario: Create planning for each event in the series
-        When we post to "/planning?add_to_series=true"
+        When we post to "/planning"
         """
         [{
             "headline": "test headline",
             "event_item": "#EVENT1._id#",
             "planning_date": "2024-11-21T12:00:00.000Z",
+            "update_method": "all",
             "coverages": [{
                 "workflow_status": "draft",
                 "news_coverage_status": {"qcode": "ncostat:int"},
@@ -157,3 +217,113 @@ Feature: Recurring Events & Planning
             ]
         }]}
         """
+
+    @auth
+    Scenario: Create planning for future events through events endpoint
+        When we patch "/events/#EVENT2._id#"
+        """
+        {
+            "embedded_planning": [{
+                "update_method": "future",
+                "coverages": [{
+                    "g2_content_type": "text",
+                    "news_coverage_status": "ncostat:int",
+                    "scheduled": "2024-11-22T15:00:00.000Z",
+                    "slugline": "test slugline",
+                    "headline": "test headline"
+                }, {
+                    "g2_content_type": "picture",
+                    "news_coverage_status": "ncostat:int",
+                    "scheduled": "2024-11-22T16:00:00.000Z",
+                    "slugline": "test slugline",
+                    "headline": "test headline"
+                }]
+            }]
+        }
+        """
+        Then we get OK response
+        When we get "/planning"
+        Then we get list with 2 items
+        """
+        {"_items": [{
+            "guid": "__any_value__",
+            "type": "planning",
+            "planning_date": "2024-11-22T12:00:00+0000",
+            "event_item": "#EVENT2._id#",
+            "recurrence_id": "#EVENT1.recurrence_id#",
+            "coverages": [
+                {"planning": {"g2_content_type": "text", "scheduled": "2024-11-22T15:00:00+0000"}},
+                {"planning": {"g2_content_type": "picture", "scheduled": "2024-11-22T16:00:00+0000"}}
+            ]
+        }, {
+            "guid": "__any_value__",
+            "type": "planning",
+            "planning_date": "2024-11-23T12:00:00+0000",
+            "event_item": "#EVENT3._id#",
+            "recurrence_id": "#EVENT1.recurrence_id#",
+            "coverages": [
+                {"planning": {"g2_content_type": "text", "scheduled": "2024-11-23T15:00:00+0000"}},
+                {"planning": {"g2_content_type": "picture", "scheduled": "2024-11-23T16:00:00+0000"}}
+            ]
+        }]}
+        """
+
+    @auth
+    Scenario: Create planning for each event in the series through events endpoint
+        When we patch "/events/#EVENT2._id#"
+        """
+        {
+            "embedded_planning": [{
+                "update_method": "all",
+                "coverages": [{
+                    "g2_content_type": "text",
+                    "news_coverage_status": "ncostat:int",
+                    "scheduled": "2024-11-22T15:00:00.000Z",
+                    "slugline": "test slugline",
+                    "headline": "test headline"
+                }, {
+                    "g2_content_type": "picture",
+                    "news_coverage_status": "ncostat:int",
+                    "scheduled": "2024-11-22T16:00:00.000Z",
+                    "slugline": "test slugline",
+                    "headline": "test headline"
+                }]
+            }]
+        }
+        """
+        Then we get OK response
+        When we get "/planning"
+        Then we get list with 3 items
+        """
+        {"_items": [{
+            "guid": "__any_value__",
+            "type": "planning",
+            "planning_date": "2024-11-21T12:00:00+0000",
+            "event_item": "#EVENT1._id#",
+            "recurrence_id": "#EVENT1.recurrence_id#",
+            "coverages": [
+                {"planning": {"g2_content_type": "text", "scheduled": "2024-11-21T15:00:00+0000"}},
+                {"planning": {"g2_content_type": "picture", "scheduled": "2024-11-21T16:00:00+0000"}}
+            ]
+        }, {
+            "guid": "__any_value__",
+            "type": "planning",
+            "planning_date": "2024-11-22T12:00:00+0000",
+            "event_item": "#EVENT2._id#",
+            "recurrence_id": "#EVENT1.recurrence_id#",
+            "coverages": [
+                {"planning": {"g2_content_type": "text", "scheduled": "2024-11-22T15:00:00+0000"}},
+                {"planning": {"g2_content_type": "picture", "scheduled": "2024-11-22T16:00:00+0000"}}
+            ]
+        }, {
+            "guid": "__any_value__",
+            "type": "planning",
+            "planning_date": "2024-11-23T12:00:00+0000",
+            "event_item": "#EVENT3._id#",
+            "recurrence_id": "#EVENT1.recurrence_id#",
+            "coverages": [
+                {"planning": {"g2_content_type": "text", "scheduled": "2024-11-23T15:00:00+0000"}},
+                {"planning": {"g2_content_type": "picture", "scheduled": "2024-11-23T16:00:00+0000"}}
+            ]
+        }]}
+        """
diff --git a/server/planning/events/events_sync/embedded_planning.py b/server/planning/events/events_sync/embedded_planning.py
index 5ef13a30f..4f69274d6 100644
--- a/server/planning/events/events_sync/embedded_planning.py
+++ b/server/planning/events/events_sync/embedded_planning.py
@@ -88,6 +88,11 @@ def map_event_to_planning_translation(translation: StringFieldTranslation):
             "coverages": [],
         }
 
+        try:
+            new_planning["update_method"] = plan["update_method"]
+        except KeyError:
+            pass
+
         if event.get("recurrence_id"):
             new_planning["recurrence_id"] = event["recurrence_id"]
 
diff --git a/server/planning/planning/planning.py b/server/planning/planning/planning.py
index 17d4535d5..7d822c796 100644
--- a/server/planning/planning/planning.py
+++ b/server/planning/planning/planning.py
@@ -9,13 +9,13 @@
 # at https://www.sourcefabric.org/superdesk/license
 
 """Superdesk Planning"""
-from typing import Dict, Any, Optional, List, Set
+from typing import Dict, Any, Optional, List
 from bson import ObjectId
 from copy import deepcopy
 import logging
-from datetime import datetime, timedelta
+from datetime import datetime
 
-from flask import json, current_app as app, request
+from flask import json, current_app as app
 from eve.methods.common import resolve_document_etag
 
 import superdesk
@@ -28,11 +28,10 @@
 from superdesk.resource import not_analyzed, string_with_analyzer
 from superdesk.users.services import current_user_has_privilege
 from superdesk.notification import push_notification
-from superdesk.default_settings import strtobool
 
 from apps.archive.common import get_user, get_auth, update_dates_for
 from eve.utils import config, ParsedRequest, date_to_str
-from planning.types import Planning, Coverage
+from planning.types import Planning, Coverage, Event, UPDATE_METHOD
 from planning.common import (
     WORKFLOW_STATE_SCHEMA,
     POST_STATE_SCHEMA,
@@ -60,6 +59,7 @@
     UPDATE_METHODS,
     UPDATE_SINGLE,
     UPDATE_FUTURE,
+    UPDATE_ALL,
 )
 from superdesk.utc import utcnow
 from itertools import chain
@@ -163,7 +163,7 @@ def on_create(self, docs):
 
             self.validate_planning(doc)
             set_original_creator(doc)
-            event = self._set_planning_event_info(doc, planning_type)
+            event: Event = self._set_planning_event_info(doc, planning_type)
             self._set_coverage(doc)
             self.set_planning_schedule(doc)
             # set timestamps
@@ -173,11 +173,13 @@ def on_create(self, docs):
             if is_ingested:
                 history_service.on_item_created([doc])
 
-            if event and request and strtobool(request.args.get("add_to_series", "false")):
-                new_plans = self._add_planning_to_event_series(doc, event)
-                if is_ingested:
-                    history_service.on_item_created(new_plans)
-                generated_planning_items.extend(new_plans)
+            update_method: Optional[UPDATE_METHOD] = doc.pop("update_method", None)
+            if event and update_method is not None:
+                new_plans = self._add_planning_to_event_series(doc, event, update_method)
+                if len(new_plans):
+                    if is_ingested:
+                        history_service.on_item_created(new_plans)
+                    generated_planning_items.extend(new_plans)
 
         if len(generated_planning_items):
             docs.extend(generated_planning_items)
@@ -360,7 +362,12 @@ def _set_planning_event_info(self, doc, planning_type) -> Optional[Dict[str, Any
 
         return event
 
-    def _add_planning_to_event_series(self, plan, event) -> List[Dict[str, Any]]:
+    def _add_planning_to_event_series(
+        self, plan: Planning, event: Event, update_method: UPDATE_METHOD
+    ) -> List[Dict[str, Any]]:
+        if update_method not in [UPDATE_FUTURE, UPDATE_ALL]:
+            return []
+
         recurrence_id = event.get("recurrence_id")
         if not recurrence_id:
             # Not a series of Events, can safely return
@@ -369,7 +376,12 @@ def _add_planning_to_event_series(self, plan, event) -> List[Dict[str, Any]]:
         plan["planning_recurrence_id"] = generate_guid(type=GUID_NEWSML)
         planning_date_relative = plan["planning_date"] - event["dates"]["start"]
         items = []
-        for series_entry in get_resource_service("events").find(where={"recurrence_id": recurrence_id}):
+
+        events_service = get_resource_service("events")
+        historic, past, future = events_service.get_recurring_timeline(event)
+        event_series = future if update_method == UPDATE_FUTURE else historic + past + future
+
+        for series_entry in event_series:
             if series_entry["_id"] == event["_id"]:
                 # This is the Event that was provided
                 # We assume a Planning item was already created for this Event