Meetings API

Era joins your meetings — with a notetaker bot or botless from your computer — briefs you before, and after writes the notes, tasks, follow-up email and next steps.

Module code meetings · 33 actions · 4 data models · 16 events. A key or token never does more here than the person behind it can; row-level security applies exactly as in the app. Scopes: meetings (everything), meetings:read (read only) or meetings:<capability>.

Resources

Lists take limit (up to 200), cursor, order (e.g. -created_at), fields and q; every other query parameter is a column filter: ?status=paid, ?total[gte]=100, ?id[in]=a,b, ?x=null.

Actions

meetings.accept_action_item

Turn an action item into a task — The commitment becomes a task for its owner (or you), with its due date, linked to the deal or customer.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.accept_action_item

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.action_item_accepted

What it writes: meeting_action_item (update) — proposed → accepted (the task follows)

curl -X POST https://app.getera.io/api/v1/meeting_action_items/MEETING_ACTION_ITEM_ID/actions/accept_action_item \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"assigneeUserId":"APP_USER_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.action_item_accepted"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetingActionItems.acceptActionItem("MEETING_ACTION_ITEM_ID", {
  assigneeUserId: "APP_USER_ID"
})

era meeting_action_items accept_action_item MEETING_ACTION_ITEM_ID \
  --assignee-user-id "APP_USER_ID"

{
  "name": "era__meetings__accept_action_item",
  "arguments": {
    "id": "MEETING_ACTION_ITEM_ID",
    "assigneeUserId": "APP_USER_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 item_not_found, item_closed, not_member · 429 slow down

meetings.accept_next_meeting

Book the suggested next meeting — Adds the next meeting Era heard agreed — same people, same deal — so Era joins and prepares for it too.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.accept_next_meeting

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.scheduled, meetings.next_meeting_booked

What it writes: meeting (insert) — Writes the next meeting; meeting (update) — suggestion → accepted

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/accept_next_meeting \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"startsAt":"2026-11-02T09:00:00Z"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.scheduled",
    "meetings.next_meeting_booked"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.acceptNextMeeting("MEETING_ID", {
  startsAt: "2026-11-02T09:00:00Z"
})

era meetings accept_next_meeting MEETING_ID \
  --starts-at "2026-11-02T09:00:00Z"

{
  "name": "era__meetings__accept_next_meeting",
  "arguments": {
    "id": "MEETING_ID",
    "startsAt": "2026-11-02T09:00:00Z"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_suggestion, suggestion_closed, bad_time, bad_join_url · 429 slow down

meetings.accept_stage

Move the deal to the suggested stage — Era read the meeting and suggests the deal’s next stage; this moves it.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.accept_stage

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.stage_accepted

What it writes: meeting (update) — suggestion → accepted (the stage change follows)

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/accept_stage \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.stage_accepted"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.acceptStage("MEETING_ID")

era meetings accept_stage MEETING_ID

{
  "name": "era__meetings__accept_stage",
  "arguments": {
    "id": "MEETING_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_suggestion, suggestion_closed · 429 slow down

meetings.add_action_item

Add an action item to a meeting — Something Era missed — who does what, by when.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.add_action_item

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.action_item_created

What it writes: meeting_action_item (insert) — Writes the item (proposed)

curl -X POST https://app.getera.io/api/v1/meeting_action_items/actions/add_action_item \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"meetingId":"MEETING_ID","text":"What"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.action_item_created"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetingActionItems.addActionItem({
  meetingId: "MEETING_ID",
  text: "What"
})

era meeting_action_items add_action_item \
  --meeting-id "MEETING_ID" \
  --text "What"

{
  "name": "era__meetings__add_action_item",
  "arguments": {
    "meetingId": "MEETING_ID",
    "text": "What"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, empty_text, not_member · 429 slow down

meetings.approve_follow_up

Approve and send the follow-up email — The email Era drafted goes out from your own Gmail or Outlook when you connected one (as you), otherwise from your business’s sender.

Needs meetings:write · reaches outside (sends, publishes or charges) · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/meetings.approve_follow_up

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.follow_up_approved

What it writes: meeting (update) — draft → approved (the send follows)

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/approve_follow_up \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.follow_up_approved"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.approveFollowUp("MEETING_ID")

era meetings approve_follow_up MEETING_ID

{
  "name": "era__meetings__approve_follow_up",
  "arguments": {
    "id": "MEETING_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_follow_up, follow_up_closed, invalid_recipient, send_from_unusable · 429 slow down

meetings.connect_calendar

Connect a calendar to meetings — Era reads your Google or Outlook calendar, prepares a brief for each meeting and joins the ones your rule picks.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.connect_calendar

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.calendar_connected

What it writes: meeting_calendar (insert) — Writes the calendar and its rule

curl -X POST https://app.getera.io/api/v1/meeting_calendars/actions/connect_calendar \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"provider":"google","credentialId":"Connected account"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.calendar_connected"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetingCalendars.connectCalendar({
  provider: "google",
  credentialId: "Connected account"
})

era meeting_calendars connect_calendar \
  --provider "google" \
  --credential-id "Connected account"

{
  "name": "era__meetings__connect_calendar",
  "arguments": {
    "provider": "google",
    "credentialId": "Connected account"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 calendar_connected · 429 slow down

meetings.delete

Delete a meeting — Removes the meeting, its transcript, notes and action items (the right to be forgotten). Tasks already made stay.

Needs meetings:delete · removes or cannot be undone · asks a person to confirm when Era runs it

• REST alias: DELETE /api/v1/meetings/{id}
• Canonical address: POST /api/v1/actions/meetings.delete

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.deleted

What it writes: meeting (delete) — Removes the meeting; meeting_action_item (delete) — Its action items go with it

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/delete \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.deleted"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.delete("MEETING_ID")

era meetings delete MEETING_ID

{
  "name": "era__meetings__delete",
  "arguments": {
    "id": "MEETING_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:delete · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, meeting_live · 429 slow down

meetings.discard_follow_up

Discard the follow-up email — No email for this meeting.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.discard_follow_up

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — draft → discarded

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/discard_follow_up \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.discardFollowUp("MEETING_ID")

era meetings discard_follow_up MEETING_ID

{
  "name": "era__meetings__discard_follow_up",
  "arguments": {
    "id": "MEETING_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_follow_up, follow_up_closed · 429 slow down

meetings.disconnect_calendar

Disconnect a meeting calendar — Era stops reading it; its upcoming meetings are dropped, past notes stay.

Needs meetings:write · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/meetings.disconnect_calendar

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting_calendar (delete) — Removes the calendar; meeting (update) — Its unrecorded upcoming meetings → cancelled

curl -X POST https://app.getera.io/api/v1/meeting_calendars/MEETING_CALENDAR_ID/actions/disconnect_calendar \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetingCalendars.disconnectCalendar("MEETING_CALENDAR_ID")

era meeting_calendars disconnect_calendar MEETING_CALENDAR_ID

{
  "name": "era__meetings__disconnect_calendar",
  "arguments": {
    "id": "MEETING_CALENDAR_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 calendar_not_found, not_your_calendar · 429 slow down

meetings.dismiss_action_item

Dismiss an action item — Era heard a commitment that was not one.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.dismiss_action_item

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting_action_item (update) — → dismissed

curl -X POST https://app.getera.io/api/v1/meeting_action_items/MEETING_ACTION_ITEM_ID/actions/dismiss_action_item \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetingActionItems.dismissActionItem("MEETING_ACTION_ITEM_ID")

era meeting_action_items dismiss_action_item MEETING_ACTION_ITEM_ID

{
  "name": "era__meetings__dismiss_action_item",
  "arguments": {
    "id": "MEETING_ACTION_ITEM_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 item_not_found, item_closed · 429 slow down

meetings.dismiss_suggestion

Dismiss a suggestion — Keep the deal where it is, or don’t book the next meeting.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.dismiss_suggestion

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — suggestion → dismissed

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/dismiss_suggestion \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"kind":"stage"}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.dismissSuggestion("MEETING_ID", {
  kind: "stage"
})

era meetings dismiss_suggestion MEETING_ID \
  --kind "stage"

{
  "name": "era__meetings__dismiss_suggestion",
  "arguments": {
    "id": "MEETING_ID",
    "kind": "stage"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_suggestion, suggestion_closed · 429 slow down

meetings.edit_follow_up

Edit the follow-up email — The recipient, subject or text of the email Era drafted after the meeting.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.edit_follow_up

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — Rewrites the draft

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/edit_follow_up \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"to":"To"}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.editFollowUp("MEETING_ID", {
  to: "To"
})

era meetings edit_follow_up MEETING_ID \
  --to "To"

{
  "name": "era__meetings__edit_follow_up",
  "arguments": {
    "id": "MEETING_ID",
    "to": "To"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_follow_up, follow_up_closed, invalid_recipient, invalid_send_from · 429 slow down

meetings.expire_audio

Delete a meeting’s recording — The audio goes now (the owner asked) or after the retention period; the transcript and notes stay.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.expire_audio

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — Drops the recording link

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/expire_audio \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.expireAudio("MEETING_ID")

era meetings expire_audio MEETING_ID

{
  "name": "era__meetings__expire_audio",
  "arguments": {
    "id": "MEETING_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_recording · 429 slow down

meetings.fail

A meeting could not be processed — The recording could not be fetched or read; the reservation is given back. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.fail

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.capture_failed

What it writes: meeting (update) — → failed, released

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, already_filed · 429 slow down

meetings.file_notes

File a meeting’s notes — Summary, decisions, action items, the follow-up draft and the suggestions — and tells workflows the meeting ended. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.file_notes

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.ended, meetings.action_item_created

What it writes: meeting (update) — → ready, with the notes and proposals; meeting_action_item (insert) — One row per commitment (proposed)

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_transcript, invalid_payload · 429 slow down

meetings.file_transcript

File a meeting’s transcript — What was said, the length and the recording; meters the notetaker’s real minutes. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.file_transcript

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — → processing, with transcript, length and cost

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, already_filed, invalid_payload, no_transcript · 429 slow down

meetings.forget_speaker

Forget a remembered speaker name — Era stops putting this name on that voice in later meetings.

Needs meetings:write · removes or cannot be undone

• Canonical address: POST /api/v1/actions/meetings.forget_speaker

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting_speaker_alias (delete) — Removes it

curl -X POST https://app.getera.io/api/v1/meeting_speaker_aliases/MEETING_SPEAKER_ALIASE_ID/actions/forget_speaker \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetingSpeakerAliases.forgetSpeaker("MEETING_SPEAKER_ALIASE_ID")

era meeting_speaker_aliases forget_speaker MEETING_SPEAKER_ALIASE_ID

{
  "name": "era__meetings__forget_speaker",
  "arguments": {
    "id": "MEETING_SPEAKER_ALIASE_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 alias_not_found · 429 slow down

meetings.link_invite

Record the calendar invite — The event Google or Outlook made (and its video link), or why it could not. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.link_invite

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.invite_sent

What it writes: meeting (update) — invite → sent / failed, with the event id

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_invite · 429 slow down

meetings.link_task

Link an action item to its task — Records the task an accepted item became. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.link_task

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting_action_item (update) — Writes the task id

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 item_not_found · 429 slow down

meetings.mark_follow_up_sent

Record the follow-up’s delivery — Queued with the sender, or refused. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.mark_follow_up_sent

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.follow_up_sent

What it writes: meeting (update) — approved → sent / failed

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, no_follow_up · 429 slow down

meetings.record_capture

Note how a recording is going — Joining, waiting room, recording, ended or failed — from the bot provider or Era Desktop. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.record_capture

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.started, meetings.capture_failed

What it writes: meeting (update) — Moves the capture state; a failure releases the reservation

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, invalid_state · 429 slow down

meetings.record_on_desktop

Record a meeting on my computer — Era Desktop records the meeting’s sound and your microphone on your own computer — nobody sees a bot. You confirm you told everyone.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.record_on_desktop

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — capture → requested on the device, consent noted

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/record_on_desktop \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"deviceId":"DEVICE_ID"}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.recordOnDesktop("MEETING_ID", {
  deviceId: "DEVICE_ID"
})

era meetings record_on_desktop MEETING_ID \
  --device-id "DEVICE_ID"

{
  "name": "era__meetings__record_on_desktop",
  "arguments": {
    "id": "MEETING_ID",
    "deviceId": "DEVICE_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, not_upcoming, already_capturing, consent_required · 429 slow down

meetings.rename_speaker

Say who a speaker is — Names a voice in the transcript (a teammate, the customer, anyone). A name the meeting platform gave is remembered for later meetings.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.rename_speaker

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — The speaker and every turn of it get the name; meeting_speaker_alias (insert) — The platform’s name for them is remembered

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/rename_speaker \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"speakerKey":"Speaker","name":"Who it is"}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.renameSpeaker("MEETING_ID", {
  speakerKey: "Speaker",
  name: "Who it is"
})

era meetings rename_speaker MEETING_ID \
  --speaker-key "Speaker" \
  --name "Who it is"

{
  "name": "era__meetings__rename_speaker",
  "arguments": {
    "id": "MEETING_ID",
    "speakerKey": "Speaker",
    "name": "Who it is"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, empty_name, invalid_recipient, speaker_not_found, not_member · 429 slow down

meetings.save_brief

Save a meeting brief — Who is coming, what they care about, what we promised, what to watch out for, the deal — written before the call. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.save_brief

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.brief_ready

What it writes: meeting (update) — Writes the brief

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, invalid_payload · 429 slow down

meetings.schedule

Add a meeting — A meeting Era should join or prepare for — paste its Zoom, Meet or Teams link, or leave it empty for a call in person.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.schedule

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.scheduled

What it writes: meeting (insert) — Writes the meeting

curl -X POST https://app.getera.io/api/v1/meetings/actions/schedule \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"title":"Name"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.scheduled"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.schedule({
  title: "Name"
})

era meetings schedule \
  --title "Name"

{
  "name": "era__meetings__schedule",
  "arguments": {
    "title": "Name"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 empty_title, bad_join_url, bad_time, not_member, invalid_payload · 429 slow down

meetings.send_bot

Send Era’s notetaker to a meeting — A bot joins the Zoom, Meet, Teams or Webex call, posts the recording notice in the chat, and records on your own notetaker account. Minutes are checked first.

Needs meetings:write · reaches outside (sends, publishes or charges)

• Canonical address: POST /api/v1/actions/meetings.send_bot

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — capture → requested

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/send_bot \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.sendBot("MEETING_ID")

era meetings send_bot MEETING_ID

{
  "name": "era__meetings__send_bot",
  "arguments": {
    "id": "MEETING_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, not_upcoming, already_capturing, no_join_link, unsupported_platform, no_bot_key, bot_minutes_used_up · 429 slow down

meetings.send_invite

Send the calendar invite — Writes the meeting into your Google or Outlook calendar with everyone on it invited (a Meet or Teams link is made when it has none).

Needs meetings:write · reaches outside (sends, publishes or charges)

• Canonical address: POST /api/v1/actions/meetings.send_invite

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — invite → pending (the calendar write follows)

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/send_invite \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.sendInvite("MEETING_ID")

era meetings send_invite MEETING_ID

{
  "name": "era__meetings__send_invite",
  "arguments": {
    "id": "MEETING_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, not_upcoming, invite_sent, no_attendees, no_calendar · 429 slow down

meetings.set_sharing

Choose who sees a meeting — Its owner always; also whoever can open its customer or deal (default), only you, or everyone in the workspace.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.set_sharing

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting (update) — Writes who sees it

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/set_sharing \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"sharing":"record"}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.setSharing("MEETING_ID", {
  sharing: "record"
})

era meetings set_sharing MEETING_ID \
  --sharing "record"

{
  "name": "era__meetings__set_sharing",
  "arguments": {
    "id": "MEETING_ID",
    "sharing": "record"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, invalid_payload, not_your_meeting · 429 slow down

meetings.skip

Don’t record a meeting — Era stays out of this meeting: no bot, no recording. The brief stays.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.skip

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.skipped

What it writes: meeting (update) — upcoming → skipped

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/skip \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.skipped"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.skip("MEETING_ID")

era meetings skip MEETING_ID

{
  "name": "era__meetings__skip",
  "arguments": {
    "id": "MEETING_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, not_upcoming · 429 slow down

meetings.sync_calendar

Read a calendar’s meetings — The next days’ events from Google or Outlook become meetings, each with the calendar’s join rule applied. Machine-only.

Needs meetings:handle · changes data

• Canonical address: POST /api/v1/actions/meetings.sync_calendar

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.scheduled

What it writes: meeting (insert) — New events become meetings; meeting (update) — Moved or cancelled events follow; meeting_calendar (update) — Last read time / error

Errors: 401 no or expired credential · 403 the credential does not hold meetings:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 calendar_not_found, invalid_payload · 429 slow down

meetings.update

Change a meeting — Name, time, link, how Era records it, and which customer, deal, conversation and knowledge base it belongs to.

Needs meetings:write · changes data

• REST alias: PATCH /api/v1/meetings/{id}
• Canonical address: POST /api/v1/actions/meetings.update

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: meetings.updated

What it writes: meeting (update) — Rewrites the meeting’s details and links

curl -X POST https://app.getera.io/api/v1/meetings/MEETING_ID/actions/update \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"title":"Name"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "meetings.updated"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetings.update("MEETING_ID", {
  title: "Name"
})

era meetings update MEETING_ID \
  --title "Name"

{
  "name": "era__meetings__update",
  "arguments": {
    "id": "MEETING_ID",
    "title": "Name"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 meeting_not_found, empty_title, bad_join_url, bad_time, not_member, not_upcoming, invalid_payload · 429 slow down

meetings.update_action_item

Change an action item — Before it becomes a task: the wording, who does it, by when.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.update_action_item

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting_action_item (update) — Rewrites the item

curl -X POST https://app.getera.io/api/v1/meeting_action_items/MEETING_ACTION_ITEM_ID/actions/update_action_item \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"text":"What"}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.meetingActionItems.updateActionItem("MEETING_ACTION_ITEM_ID", {
  text: "What"
})

era meeting_action_items update_action_item MEETING_ACTION_ITEM_ID \
  --text "What"

{
  "name": "era__meetings__update_action_item",
  "arguments": {
    "id": "MEETING_ACTION_ITEM_ID",
    "text": "What"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold meetings:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 item_not_found, item_closed, empty_text, not_member · 429 slow down

meetings.update_calendar

Change a meeting calendar — Who Era joins, how it records, where the notes go, or pause the calendar.

Needs meetings:write · changes data

• Canonical address: POST /api/v1/actions/meetings.update_calendar

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: meeting_calendar (update) — Rewrites the rule

curl -X POST https://app.getera.io/api/v1/meeting_calendars/MEETING_CALENDAR_ID/actions/update_calendar \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"joinRule":"all"}'

{
  "ok": true,
  "result": "…",
  "events": []
}