Demo.py option: "[a] Scheduled workouts, next 60 days (incl. adaptive plans)" Not Returning Adaptive Plan Workouts

[rissoftwareeng]

Hi everyone!

I’m trying to retrieve scheduled workouts from an active Garmin Coach adaptive cycling plan, but get_scheduled_workouts_by_period() returns an empty list even though the workouts appear in my Garmin Connect calendar.

Before opening a PR, I’d like to confirm whether this is a bug, an unsupported feature, or an issue with how I’m using the API.

Steps to reproduce

1. Run demo.py and log in to an account with an active Garmin Coach adaptive plan.
2. Select #b 📅 Training Plans & Calendar.
3. Select [a] Scheduled workouts, next 60 days (incl. adaptive plans).
4. Check the terminal output and your_data/response.json.

Actual behavior

The request returns an empty list:

-------------------- api.get_scheduled_workouts_by_period('2026-10-28', '2026-12-27') --------------------
[]
-----------------------------------------------------------------------------

However, Garmin Connect shows scheduled workouts for October 28–29 within that date range:

The [1] Get training plans option also returns the active plan. Relevant excerpt:

{
  "trainingPlanList": [
    {
      "trainingPlanId": 48013240,
      "trainingPlanCategory": "FBT_ADAPTIVE",
      "trainingType": {
        "typeId": 3,
        "typeKey": "Cycling"
      }
    }
  ]
}

Expected behavior

Because the menu option explicitly says “incl. adaptive plans,” I expected the response to include the scheduled workouts from my Garmin Coach adaptive plan—at least those shown in the calendar for October 28–29.

Proposed next step

I’m happy to investigate and submit a PR, but I’d appreciate confirmation from the maintainers first:

• Is this method intended to return scheduled Garmin Coach adaptive plan workouts?
• If so, would you welcome a PR to address this discrepancy?

Environment

• Project release: 0.3.20
• Operating system: macOS Tahoe 26.7

[SumiyaE]

Not a maintainer, but a few things from the 0.3.20 source that should narrow this down.

What the method actually sends

get_scheduled_workouts_by_period() calls GET /workout-service/schedule/workoutScheduleByPeriod with only startDate and endDate. The "including adaptive plans" wording lives in the docstring; nothing in the request asks for them:

python-garminconnect/garminconnect/api/workouts.py

Lines 412 to 423 in 3eee7a4

	def get_scheduled_workouts_by_period(
	self, start: str, end: str
	) -> list[dict[str, Any]]:
	"""Return all scheduled workouts between two dates, including adaptive plans.
	GET /workout-service/schedule/workoutScheduleByPeriod?startDate&endDate
	— the call behind the web app's upcoming-workouts view.
	"""
	start, end = _validate_date_range(start, end)
	url = f"{self.garmin_connect_workout_service_url}/schedule/workoutScheduleByPeriod"
	logger.debug("Requesting scheduled workouts by period")
	return self.connectapi(url, params={"startDate": start, "endDate": end})

And docs/API_ENDPOINTS.md records that this call was verified as "yes (empty)", i.e. it was executed against a real account but returned an empty list there too. So "includes adaptive-plan sessions" was never confirmed against an account with an active FBT_ADAPTIVE plan:

python-garminconnect/docs/API_ENDPOINTS.md

Line 249 in 3eee7a4

| `get_scheduled_workouts_by_period(start, end)` | `GET /workout-service/schedule/workoutScheduleByPeriod?startDate&endDate` | Includes adaptive-plan sessions; the proper source for "next workout". | yes (empty) |

That makes your report the first real data point rather than a misuse on your side.

Three quick checks you can run with your account (I don't have a Coach plan, so these are untested suggestions, not confirmed fixes)

1. The calendar endpoint. get_scheduled_workouts(year, month) reads /calendar-service/year/{y}/month/{m-1}, which is what the calendar you screenshotted is backed by. If the Oct 28–29 items show up in calendarItems here, the library already has a working path and the by-period docstring is just wrong:
   

   python-garminconnect/garminconnect/api/workouts.py

   Lines 322 to 339 in 3eee7a4

   	def get_scheduled_workouts(
   	self, year: int | str, month: int | str
   	) -> dict[str, Any]:
   	"""Return the scheduled workouts of a calendar month."""
   	year = _coerce_positive_id(year, "year")
   	if year < 2000:
   	raise ValueError(f"year must be 2000 or later, got: {year}")
   	month = _coerce_positive_id(month, "month")
   	if month < 1 or month > 12:
   	raise ValueError(f"month must be between 1 and 12, got: {month}")
   	# Garmin's API uses 0-indexed months, so we need to subtract 1 from the month value
   	url = f"{self.garmin_scheduled_workouts_url}/year/{year}/month/{month - 1}"
   	logger.debug(
   	"Requesting scheduled workout for year %d and month %d", year, month
   	)
   	return self.connectapi(url)

   data = api.get_scheduled_workouts(2026, 10)
   print([i for i in data.get("calendarItems", []) if i.get("date", "") >= "2026-10-28"])

2. includeAtp=true on the same endpoint. The same workout-service already takes an includeAtp flag on /workouts and /workouts/count in this library, so it is a cheap thing to try on the schedule call:
   

   python-garminconnect/garminconnect/api/workouts.py

   Lines 58 to 64 in 3eee7a4

   	params: dict[str, Any] = {"start": start, "limit": limit}
   	for key, value in (
   	("myWorkoutsOnly", my_workouts_only),
   	("sharedWorkoutsOnly", shared_workouts_only),
   	("includeAtp", include_atp),
   	):
   	if value is not None:

   
   

   python-garminconnect/garminconnect/api/workouts.py

   Lines 425 to 434 in 3eee7a4

   	def get_workout_count(self, include_atp: bool = False) -> dict[str, Any]:
   	"""Return workout counts per sport (``totalCount``, ``runningCount``, ...).
   	GET /workout-service/workouts/count?includeAtp=.
   	"""
   	url = f"{self.garmin_connect_workout_service_url}/workouts/count"
   	logger.debug("Requesting workout count")
   	return self.connectapi(
   	url, params={"includeAtp": str(bool(include_atp)).lower()}
   	)

   api.connectapi(
       "/workout-service/schedule/workoutScheduleByPeriod",
       params={"startDate": "2026-10-28", "endDate": "2026-12-27", "includeAtp": "true"},
   )

3. The plan itself. get_training_plan_tasks(48013240) and get_adaptive_training_plan_by_id(48013240) read the plan's own task list, which may be where Coach workouts live before they are committed to the calendar:
   

   python-garminconnect/garminconnect/api/training.py

   Lines 33 to 41 in 3eee7a4

   	def get_training_plan_tasks(self, plan_id: int | str, locale: str = "en") -> Any:
   	"""Return the workout tasks of a training plan.
   	GET /trainingplan-service/trainingplan/tasks/{planId}?localeKey=.
   	"""
   	plan_id = _coerce_positive_id(plan_id, "plan_id")
   	url = f"{self.garmin_connect_training_plan_url}/tasks/{plan_id}"
   	logger.debug("Requesting training plan tasks %s", plan_id)
   	return self.connectapi(url, params={"localeKey": locale})

   
   

   python-garminconnect/garminconnect/api/training.py

   Lines 497 to 503 in 3eee7a4

   	def get_adaptive_training_plan_by_id(self, plan_id: int | str) -> dict[str, Any]:
   	"""Return details for a specific adaptive training plan."""
   	plan_id = _coerce_positive_id(plan_id, "plan_id")
   	url = f"{self.garmin_connect_training_plan_url}/fbt-adaptive/{plan_id}"
   	logger.debug("Requesting adaptive training plan details for %s", plan_id)
   	return self.connectapi(url)

The most reliable way to settle it is to open the Garmin Connect web app's training-plan page with DevTools → Network and copy the exact workout-service request it makes (path and query string); whatever that request sends is what the library should send. If (2) turns out to be the missing piece, a PR adding an include_atp keyword to get_scheduled_workouts_by_period, mirroring get_workouts, would be a one-line change plus docs.

[rissoftwareeng]

Hi SumiyaE, thanks for the helpful suggestions!

Good catch on the “yes (empty)” verification status—it doesn’t establish that the by-period endpoint returns workouts for an active adaptive plan.

I ran all three checks you suggested:

1. get_scheduled_workouts(2026, 10) returned calendar entries from my adaptive plan, including the October 29 session with itemType: "fbtAdaptiveWorkout" and tpType: "FBT_ADAPTIVE".
2. Adding includeAtp=true to the by-period request still returned an empty list for my account.
3. get_adaptive_training_plan_by_id(48013240) returned a populated taskList with my dated Coach sessions, including the October 29 Base workout.

I also checked the browser’s Network panel. The training-plan page requests /trainingplan-service/trainingplan/fbt-adaptive/{planId} with no query string, and its response contains those sessions.

Based on these results, the by-period docstring’s “including adaptive plans” wording appears to need correction or clarification: the call returned no adaptive-plan workouts for my account, even with includeAtp=true.

For the demo’s [a] Scheduled workouts, next 60 days (incl. adaptive plans) option, could the implementation combine results from get_scheduled_workouts_by_period() with the taskList returned by get_adaptive_training_plan_by_id(), filtering the adaptive sessions to the requested date range and removing duplicates?

[SumiyaE]

Thanks for running all three, that settles the question: on an account with an active FBT_ADAPTIVE plan, workoutScheduleByPeriod returns nothing for the adaptive sessions, with or without includeAtp. So the docstring's "including adaptive plans" is the part that's wrong.

Combining the two sounds right to me. Two things I'd keep in mind, from the current source (fe7ef9b):

Finding the plan ID. get_active_training_plans(date) returns a trainingPlanList with trainingPlanCategory on each entry, and the demo already uses that category to route FBT_ADAPTIVE plans to get_adaptive_training_plan_by_id(). The [a] option could reuse the same check instead of asking for an ID:

python-garminconnect/garminconnect/api/training.py

Lines 23 to 31 in fe7ef9b

	def get_active_training_plans(self, cdate: str | None = None) -> dict[str, Any]:
	"""Return the training plans active on a date (``trainingPlanList``).
	GET /trainingplan-service/trainingplan/active-plans?startDate=.
	"""
	cdate = self._date_or_today(cdate)
	url = f"{self.garmin_connect_training_plan_url}/active-plans"
	logger.debug("Requesting active training plans")
	return self.connectapi(url, params={"startDate": cdate})

python-garminconnect/demo.py

Lines 2745 to 2750 in fe7ef9b

	if plan_category == "FBT_ADAPTIVE":
	call_and_display(
	api.get_adaptive_training_plan_by_id,
	plan_id,
	method_name="get_adaptive_training_plan_by_id",
	api_call_desc=f"api.get_adaptive_training_plan_by_id({plan_id}) - {plan_name}",

Filtering and de-duplication. I don't have a Coach plan, so I don't know the exact field names inside taskList. Filter on whatever date key your Oct 29 task carries. Since by-period returned nothing adaptive for you, there's no overlap today; de-duplicating on (date, workout ID) would only matter if Garmin starts returning those sessions there later.

A simpler alternative you've already proven works: check 1 showed the calendar endpoint returns the adaptive sessions (itemType: "fbtAdaptiveWorkout") with a date. Reading the months that cover the 60-day window and filtering by date and itemType would need no plan lookup and would also cover more than one active plan:

python-garminconnect/garminconnect/api/workouts.py

Lines 322 to 339 in fe7ef9b

	def get_scheduled_workouts(
	self, year: int | str, month: int | str
	) -> dict[str, Any]:
	"""Return the scheduled workouts of a calendar month."""
	year = _coerce_positive_id(year, "year")
	if year < 2000:
	raise ValueError(f"year must be 2000 or later, got: {year}")
	month = _coerce_positive_id(month, "month")
	if month < 1 or month > 12:
	raise ValueError(f"month must be between 1 and 12, got: {month}")
	# Garmin's API uses 0-indexed months, so we need to subtract 1 from the month value
	url = f"{self.garmin_scheduled_workouts_url}/year/{year}/month/{month - 1}"
	logger.debug(
	"Requesting scheduled workout for year %d and month %d", year, month
	)
	return self.connectapi(url)

from datetime import date, timedelta

def scheduled_in_range(api, start: date, end: date):
    items, y, m = [], start.year, start.month
    while (y, m) <= (end.year, end.month):
        cal = api.get_scheduled_workouts(y, m) or {}
        items += cal.get("calendarItems", [])
        y, m = (y + 1, 1) if m == 12 else (y, m + 1)
    return [
        i for i in items
        if start.isoformat() <= i.get("date", "") <= end.isoformat()
        and i.get("itemType") in ("workout", "fbtAdaptiveWorkout")
    ]

scheduled_in_range(api, date.today(), date.today() + timedelta(days=60))

(Untested: I'm assuming regular scheduled workouts show up as itemType: "workout" in the same response; worth checking on your account.)

Either way, this is a maintainer's call, so I'd open an issue or PR with your findings. The Network-panel result (/trainingplan-service/trainingplan/fbt-adaptive/{planId}, no query string) is the strongest evidence for how the web app gets these sessions.