How much does zuzu.codes cost?

The starter track is free — read all lessons and practice for free. Full access to every track (current and future) is $14.99/month. Cancel anytime.

How long does each track take?

Each track is designed as a 30-day challenge — one lesson per day, about 15 minutes each. Go at your own pace, but the structure is built around daily consistency.

What's the lesson format?

Each lesson is a student-teacher dialogue with code examples, followed by a hands-on code challenge in an in-browser editor. You read, you understand, then you write real code.

Do I need prior coding experience?

Our beginner track starts from absolute zero — no prior experience needed. Advanced tracks build on earlier ones, and the platform tells you exactly where to start.

How is zuzu.codes different from freeCodeCamp or Codecademy?

zuzu.codes uses a structured 30-day track format with dialogue-based teaching, an in-browser code editor, and gamification (XP, streaks, progress tracking). The format builds genuine understanding through daily practice.

Combine Gmail and Calendar Counts Into One Dict — Automation For Makers

Day 4 · ~12 min●

Two APIs, two counts, one dict. Email count, event count, total — all returned together so callers never have to add the numbers themselves. What's the minimum number of API calls?

Two, I think? One for Gmail, one for Calendar? Do they run back-to-back?

Right. Both respond with a dict. Gmail's list lives under messages, Calendar's under items. Count each list, then compute the total inside the return dict:

python

emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": 5})
events = toolset.execute_action(Action.GOOGLECALENDAR_FIND_EVENT, {"query": ""})
email_count = len(emails.get("messages", []))
event_count = len(events.get("items", []))

So each API's response key is different, but the defensive .get(key, []) pattern stays identical.

Exactly. The key name changes per API, the shape of the code does not. Wrap it into a function that returns a three-field dict with the derived total included:

python

def combine_counts(max_emails: int, max_events: int) -> dict:
    emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": max_emails})
    events = toolset.execute_action(Action.GOOGLECALENDAR_FIND_EVENT, {"query": ""})
    email_count = len(emails.get("messages", []))
    event_count = len(events.get("items", []))
    result = {"emails": email_count, "events": event_count, "total": email_count + event_count}
    print(f"Combined counts: {result}")
    return result

Why include the total field if the caller can compute it from the other two?

Because a good return contract answers the question the caller asked. If they wanted a summary, force them to do arithmetic to see it. Including the derived total makes the return self-sufficient.

And both counts run against my real Gmail and my real Calendar — the total reflects what's actually in each right now?

Live counts, live dict. One function, two APIs, three fields — the production shape of every Week 1 aggregator from here.

Two-API Aggregator

TL;DR: One function calls two APIs, counts each list, returns a dict with both counts plus a derived total.

Different keys per API — Gmail: messages, Calendar: items; defensive .get(key, []) each time
Derived field — "total": a + b computed inside the dict literal
Single return — caller reads result["emails"] / result["events"] / result["total"]

Key name reference

API	Response key
`GMAIL_FETCH_EMAILS`	`messages`
`GOOGLECALENDAR_FIND_EVENT`	`items`
`GOOGLETASKS_LIST_TASKS`	`items`

Day 4 · ~12 min●

Two APIs, two counts, one dict. Email count, event count, total — all returned together so callers never have to add the numbers themselves. What's the minimum number of API calls?

Two, I think? One for Gmail, one for Calendar? Do they run back-to-back?

Right. Both respond with a dict. Gmail's list lives under messages, Calendar's under items. Count each list, then compute the total inside the return dict:

python

emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": 5})
events = toolset.execute_action(Action.GOOGLECALENDAR_FIND_EVENT, {"query": ""})
email_count = len(emails.get("messages", []))
event_count = len(events.get("items", []))

So each API's response key is different, but the defensive .get(key, []) pattern stays identical.

Exactly. The key name changes per API, the shape of the code does not. Wrap it into a function that returns a three-field dict with the derived total included:

python

def combine_counts(max_emails: int, max_events: int) -> dict:
    emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": max_emails})
    events = toolset.execute_action(Action.GOOGLECALENDAR_FIND_EVENT, {"query": ""})
    email_count = len(emails.get("messages", []))
    event_count = len(events.get("items", []))
    result = {"emails": email_count, "events": event_count, "total": email_count + event_count}
    print(f"Combined counts: {result}")
    return result

Why include the total field if the caller can compute it from the other two?

Because a good return contract answers the question the caller asked. If they wanted a summary, force them to do arithmetic to see it. Including the derived total makes the return self-sufficient.

And both counts run against my real Gmail and my real Calendar — the total reflects what's actually in each right now?

Live counts, live dict. One function, two APIs, three fields — the production shape of every Week 1 aggregator from here.

Two-API Aggregator

TL;DR: One function calls two APIs, counts each list, returns a dict with both counts plus a derived total.

Different keys per API — Gmail: messages, Calendar: items; defensive .get(key, []) each time
Derived field — "total": a + b computed inside the dict literal
Single return — caller reads result["emails"] / result["events"] / result["total"]

Key name reference

API	Response key
`GMAIL_FETCH_EMAILS`	`messages`
`GOOGLECALENDAR_FIND_EVENT`	`items`
`GOOGLETASKS_LIST_TASKS`	`items`

emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": 5}) events = toolset.execute_action(Action.GOOGLECALENDAR_FIND_EVENT, {"query": ""}) email_count = len(emails.get("messages", [])) event_count = len(events.get("items", []))

def combine_counts(max_emails: int, max_events: int) -> dict: emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": max_emails}) events = toolset.execute_action(Action.GOOGLECALENDAR_FIND_EVENT, {"query": ""}) email_count = len(emails.get("messages", [])) event_count = len(events.get("items", [])) result = {"emails": email_count, "events": event_count, "total": email_count + event_count} print(f"Combined counts: {result}") return result

Two-API Aggregator

TL;DR: One function calls two APIs, counts each list, returns a dict with both counts plus a derived total.

Different keys per API — Gmail: messages, Calendar: items; defensive .get(key, []) each time

Derived field — "total": a + b computed inside the dict literal

Single return — caller reads result["emails"] / result["events"] / result["total"]

Key name reference

API	Response key
`GMAIL_FETCH_EMAILS`	`messages`
`GOOGLECALENDAR_FIND_EVENT`	`items`
`GOOGLETASKS_LIST_TASKS`	`items`

Two-API Aggregator

TL;DR: One function calls two APIs, counts each list, returns a dict with both counts plus a derived total.

Different keys per API — Gmail: messages, Calendar: items; defensive .get(key, []) each time

Derived field — "total": a + b computed inside the dict literal

Single return — caller reads result["emails"] / result["events"] / result["total"]

Key name reference

API	Response key
`GMAIL_FETCH_EMAILS`	`messages`
`GOOGLECALENDAR_FIND_EVENT`	`items`
`GOOGLETASKS_LIST_TASKS`	`items`

Two-API Aggregator

Key name reference

Two-API Aggregator

Key name reference

Two-API Aggregator

Key name reference

Sign up to practice

Two-API Aggregator

Key name reference

Sign up to practice