Skip to content

Response reference ​

What every rimo command returns, field by field. For the commands themselves (syntax, flags, examples) see Commands; for the output contract and error format see Output & errors.

How to read this page ​

  • Presence is either Always (the field is in every response) or Optional. An optional field is omitted entirely when it has no value — it is not returned as null or "", so check for the key's presence rather than comparing to an empty value. The one exception is Participant.user_id, which is always present but is "" for a speaker with no Rimo account.
  • Timestamps are RFC 3339 strings in the caller's local timezone, for example "2026-07-05T15:45:20.47178+09:00".
  • Key order is not part of the contract — do not rely on it.

What each command returns ​

CommandFormatShape
rimo auth loginJSONLogin and switch result
rimo auth logoutJSONLogout result
rimo auth statusJSONAuth status
rimo auth switchJSONLogin and switch result
rimo note listJSON{notes: Note[], next_page_token}
rimo note getJSON{note: Note}
rimo note get --list-documentsJSON{documents: Document[]}
rimo note get --transcript / --document / --full / --meeting-chat / --document-idPlain textNote content
rimo note searchJSON{notes: Search result[], total_count}
rimo note askPlain textAsk answer
rimo note createJSON{note: Note, document: Document}
rimo note appendJSON{document: Document}
rimo note asset listJSON{assets: Asset[]}
rimo note asset getMarkdownAttachment
rimo note asset get --jsonJSONAssetDetail (one flat record)
rimo note asset uploadJSON{asset: Asset, document: Document}
rimo team listJSON{teams: Team[], next_page_token}
rimo appointment link listJSON{appointment_links: Appointment link[]}
rimo appointment link getJSON{appointment_link: Appointment link detail}
rimo appointment link createJSON{appointment_link: Appointment link detail, warnings: Appointment link warning[], dry_run}
rimo appointment link updateJSON{appointment_link: Appointment link detail, warnings: Appointment link warning[], dry_run} — the whole link after the change
rimo appointment link enable / disableJSONSame as update, with disabled now false / true
rimo appointment link deleteJSONAppointment link delete result (one flat record, not an envelope)
rimo appointment listJSON{appointments: Appointment[]}
rimo appointment cancelJSON{appointment: Appointment, dry_run} — with status now cancelled (confirmed on --dry-run)
rimo versionPlain textOne version line
rimo upgradePlain textOne status line
rimo mcp—An MCP server on stdio, not a data command. See MCP.

rimo login and rimo logout are aliases for rimo auth login / rimo auth logout and return the same shapes.

Any command can fail instead, in which case it prints an error object and exits non-zero, with an exit code that depends on the kind of failure.

Envelopes ​

Every JSON response except appointment link delete wraps its payload under a container key, alongside any scalar metadata:

EnvelopeReturned by
{notes: [...], next_page_token: "..."}note list
{notes: [...], total_count: <int>}note search
{teams: [...], next_page_token: "..."}team list
{appointment_links: [...]}appointment link list
{appointment_link: {...}}appointment link get
{appointment_link: {...}, warnings: [...], dry_run: <bool>}appointment link create, update, enable, disable (--fields / --excludes apply to the link only)
{appointments: [...]}appointment list
{appointment: {...}, dry_run: <bool>}appointment cancel (--fields / --excludes apply to the appointment only)
{note: {...}}note get
{documents: [...]}note get --list-documents
{note: {...}, document: {...}}note create
{document: {...}}note append
{accounts: [...], active_account: "..."}auth status

--fields and --excludes apply to the records inside the envelope; the scalar metadata siblings (next_page_token, total_count, active_account) are always preserved. So rimo note list --fields id,title trims each note but keeps next_page_token. See Field filtering.

appointment link delete is not wrapped: its result is one flat record whose own keys the flags apply to (see Appointment link delete result).

next_page_token is a cursor: pass it back as --page-token to fetch the next page, and stop when it is absent.

Note ​

Returned inside {note: ...} by note get and note create, and inside {notes: [...]} by note list.

FieldTypePresenceDescription
idstringAlwaysThe note ID. Pass it to note get, note append, and the other note commands.
titlestringAlwaysThe note title.
statestringAlwaysWhere the note is in the recording/transcription pipeline. See Note states.
durationintegerAlwaysMedia length in milliseconds. 0 for notes with no recording.
created_atstringAlwaysWhen the note was created.
updated_atstringAlwaysWhen the note was last updated. Filter on this with note list --updated-since.
user_idstringOptionalID of the user who owns the note.
organization_idstringOptionalID of the organization the note belongs to. Absent for personal notes.
team_idstringOptionalID of the team the note belongs to. Absent for personal notes. Pass it to note list --team.
localestringOptionalTranscription language, e.g. ja-JP.
media_typestringOptionalKind of media attached, e.g. audio, none.
sourcestringOptionalHow the note was created, e.g. none, zoom_import. New values are added as integrations are added.
held_atstringOptionalWhen the meeting took place. Filter on this with note list --since / --until.
memostringOptionalFree-text memo added to the note.
share_modestringOptionalLink sharing: nothing (not shared), view, or edit.
custom_template_idstringOptionalID of the custom template used for the minutes.
webhook_urlstringOptionalWebhook called when processing completes.
document_markdownstringOptionalThe primary document's markdown. See the note below.
tagsstring[]OptionalTag names on the note. See the note below.
participantsParticipant[]OptionalMeeting participants. See the note below.

note list and note get return metadata only. They never populate document_markdown, tags, or participants, because loading a note's content is the expensive part and most callers only need the metadata. To read content, use the dedicated flags — note get --document, --transcript, --full, --list-documents — which return plain text or Document records.

Note states ​

state tracks the note through recording, media conversion, and speech recognition. Treat it as an open set: match the values you care about and handle unknown ones gracefully, because new states are added as new capture methods ship.

StateMeaning
NOTE_CREATEDNote created with no media registered (e.g. by note create).
NOT_SCHEDULEDNo bot recording scheduled.
RECORDING_SCHEDULEDBot recording is scheduled.
RECORDING_WAITINGBot joined the meeting and is waiting to start (e.g. host approval).
RECORDING_STARTEDBot recording is in progress.
RECORDING_PAUSEDBot recording is paused.
RECORDING_DONEBot recording finished.
RECORDING_FAILEDBot recording failed and generally cannot be retried.
MIC_RECORDING_REQUESTED / MIC_RECORDING_STARTED / MIC_RECORDING_DONEMicrophone recording not yet started / in progress / finished.
HARDWARE_RECORDING_REQUESTED / HARDWARE_RECORDING_STARTEDHardware recording not yet started / in progress.
TRANSCRIPTION_DONEReal-time transcription finished, but the media has not been uploaded.
MEDIA_PREPARINGAudio or video is uploading.
VC_WAITINGAudio uploaded, waiting for permission to process.
VC_REQUESTEDMedia conversion in progress.
VC_ERRORMedia conversion failed.
ASR_PROCESSINGSpeech recognition in progress.
ASR_ERRORSpeech recognition failed.
ASR_DONESpeech recognition finished — the transcript and minutes are ready.

Participant ​

A meeting participant. Returned inside a Note's participants array.

FieldTypePresenceDescription
user_idstringAlwaysThe participant's Rimo user ID. Empty when the speaker has no Rimo account. Pass it to note search --participant.
idstringOptionalInternal participant ID.
namestringOptionalDisplay name.
emailstringOptionalEmail address.
calendar_namestringOptionalAttendee name from the calendar event, for notes created from a calendar.
speaker_idstringOptionalDiarization speaker identifier, used to attribute transcript lines to this participant.

Document ​

A document (minutes) attached to a note. A note can have several — translations, different templates — and primary marks the canonical one.

Returned inside {documents: [...]} by note get --list-documents, and inside {document: ...} by note create and note append.

FieldTypePresenceDescription
idstringAlwaysThe document ID. Pass it to note append and note get --document-id.
note_idstringAlwaysID of the note this document belongs to.
titlestringAlwaysThe document title.
primarybooleanAlwaystrue for the note's canonical minutes document.
created_atstringAlwaysWhen the document was created.
updated_atstringAlwaysWhen the document was last updated.
export_markdownstringOptionalThe document body as markdown.
localestringOptionalDocument language, e.g. ja-JP.
categorystringOptionalWhat kind of document it is, e.g. agenda, summary, translation.
template_modestringOptionalTemplate the document was generated from, e.g. minutes.
custom_template_idstringOptionalID of the custom template used.

--list-documents includes every document's full export_markdown, so the response grows with the note's content — a note with a few translations can run to tens of kilobytes. When you only need the IDs and titles, drop the bodies:

bash
rimo note get <note_id> --list-documents --excludes export_markdown

Asset ​

A file attachment — an uploaded file or an image embedded in the body — referenced by one of a note's documents.

Returned inside {assets: [...]} by note asset list, as the single {asset: ...} just-uploaded attachment by note asset upload, and as asset in AssetDetail by note asset get --json.

FieldTypePresenceDescription
idstringAlwaysThe attachment's ID.
namestringAlwaysThe file name.
mime_typestringOptionalThe file's MIME type. Omitted when unknown.
size_bytesintegerOptionalFile size in bytes. Omitted when unknown — images embedded in the body usually don't carry a size.
uploaded_atstringAlwaysWhen the file was uploaded.
summary_statusstringAlwaysWhether summary is available: none (no summary for now, and analysis may not have started yet — a newly uploaded attachment can show none for a short time before pending or processing; also used when the file type is not analyzed, nothing readable was found, or an image was skipped because the note reached its analyzed-image limit), pending (waiting to be analyzed), processing (being analyzed), completed (the summary is available) or failed (the latest analysis failed; some failures are retried automatically, so it can still change).
summarystringOptionalA short summary from the attachment's analysis. Present exactly when summary_status is completed.

AssetDetail ​

One attachment with its analysis and extracted text. Returned by note asset get --json (without --json the same data is printed as Markdown — see Attachment). It is one record, so --fields / --excludes select its top-level keys (--excludes content keeps only the metadata).

FieldTypePresenceDescription
assetAssetAlwaysThe attachment's details, including summary when analyzed.
analysisobjectAlwaysThe analysis state — fields below.
analysis.statusstringAlwaysnone (not analyzed), pending, processing, completed, unsupported (file type not analyzed), skipped (the image was not analyzed because the note already has the maximum number of analyzed images (200); error_code is image_limit_reached and the asset's summary_status is none), or failed.
analysis.error_codestringOptionalWhy the analysis failed, or image_limit_reached for a skipped image.
analysis.coveragestringOptionalHow the text was obtained: text, ocr, visual_description, partial (only part of the file could be read), or none.
analysis.page_countintegerOptionalNumber of pages, when known.
analysis.unreadable_page_countintegerOptionalPages that could not be read, when known.
analysis.vision_appliedbooleanAlwaysWhether images were read with image recognition.
analysis.unread_visualsobjectOptionalImages or charts that were not read: count, kinds, pages, and pages_truncated (the page list is cut short).
analysis.cardobjectOptionalPresent only for a completed analysis: summary, document_type (omitted when unknown) and language.
contentstringOptionalThe extracted text as Markdown, exactly as stored, including <!-- @loc page_from=… page_to=… --> page markers. Absent when there is none yet. Can be present for a failed analysis.
content_size_bytesintegerOptionalSize of the full extracted text, in bytes.
content_truncatedbooleanOptionaltrue when content was cut to 1 MiB (or, on the MCP tool note_get_asset, to 200,000 characters).

Reading an attachment never starts or re-runs its analysis.

Team ​

Returned inside {teams: [...]} by team list.

FieldTypePresenceDescription
idstringAlwaysThe team ID. Pass it to note list --team, note search --team, and note create --team.
namestringAlwaysThe team name — this is the folder name shown in the Rimo app.
categorystringOptional"team" for a team folder. "organization" marks your organization's own folder, returned only with --include-organization; its id is the organization ID.
is_private_channelbooleanAlwaystrue when only team members can read the team's notes.
member_idsstring[]AlwaysUser IDs of the team's members.
created_atstringAlwaysWhen the team was created.
updated_atstringAlwaysWhen the team was last updated.
parent_idstringOptionalID of the parent team.
descriptionstringOptionalThe team description.

Returned inside {appointment_links: [...]} by appointment link list. appointment link get returns the same fields plus the link's settings — see Appointment link detail.

FieldTypePresenceDescription
idstringAlwaysThe link ID. Pass it to appointment link get or appointment list. "" in a create --dry-run response.
urlstringAlwaysThe booking page to share with a guest. "" in a create --dry-run response: the link does not exist yet.
edit_urlstringAlwaysThe link's editor in the Rimo app, where calendar and meeting tools are connected. "" in a create --dry-run response.
titlestringAlwaysThe link title.
duration_minutesintegerAlwaysMeeting length in minutes.
disabledbooleanAlwaystrue when you switched the link off (appointment link disable): it takes no new bookings. Switch it back on with appointment link enable.
closedbooleanAlwaystrue when a single-use link was booked. It cannot accept appointments again.
single_usebooleanAlwaystrue when the link closes after its first appointment.
calendar_providerstringAlwaysgoogle or outlook: the calendar used for free/busy and the event.
meeting_providersstring[]AlwaysMeeting tools tried in order for the meeting URL (google_meet, zoom, microsoft_teams). Empty means no meeting URL is issued.
participantsobject[]AlwaysMembers of your organization who join every appointment: user_id, plus name and email when they could be looked up.
created_atstringAlwaysWhen the link was created.
updated_atstringAlwaysWhen the link was last updated.

Returned inside {appointment_link: {...}} by appointment link get, create, update, enable and disable: every Appointment link field, plus the link's settings below. The names are the same ones the create -f and update -f files use.

FieldTypePresenceDescription
descriptionstringAlwaysText shown to the guest on the booking page.
availability_rulesobject[]AlwaysBookable hours: weekday (integer, 0 = Sunday … 6 = Saturday), start_time and end_time (HH:MM in time_zone). A weekday can appear more than once.
time_zonestringAlwaysIANA time zone (for example Asia/Tokyo) the hours, closes_on and time_overrides are read in.
days_in_advanceintegerAlwaysHow many days ahead a guest can book.
closes_onstringAlwaysLast day the link accepts bookings (YYYY-MM-DD in time_zone). Empty means no end date.
min_notice_hoursintegerAlwaysMinimum hours between booking and the start of the appointment.
buffer_before_minutesintegerAlwaysFree time kept before your existing events, in minutes. 0 keeps none.
buffer_after_minutesintegerAlwaysFree time kept after your existing events, in minutes. 0 keeps none.
appointment_slot_interval_minutesintegerAlwaysStep between offered start times, in minutes. 0 means the meeting length.
cancellation_deadline_hoursintegerAlwaysA guest can cancel up to this many hours before the start. 0 means until the start.
auto_reserve_recordingbooleanAlwaystrue when booked meetings are recorded automatically.
disable_appointment_confirmed_emailbooleanAlwaystrue when no booking confirmation email is sent.
share_note_with_guestbooleanAlwaystrue when the meeting's note is shared with the guest afterwards.
include_keywordsstring[]AlwaysEvents whose title contains one of these (case-insensitive) count as free time.
include_keywords_onlybooleanAlwaystrue when only the times of events matching include_keywords are offered.
exclude_keywordsstring[]AlwaysTimes of events whose title contains one of these are never offered. Wins over include_keywords.
holiday_countriesstring[]AlwaysCountries (ISO 3166-1 alpha-2, for example JP) whose public holidays are not offered.
time_overridesobject[]AlwaysDate-specific adjustments: type (block removes the time, open offers it even when your calendar is busy), start_date / end_date (YYYY-MM-DD; both empty means every day), start_time / end_time (HH:MM), and a note for you.
poll_enabledbooleanAlwaystrue when the link collects several people's availability first and you confirm the time.

Returned inside warnings by appointment link create, update, enable and delete: something worth knowing that did not stop the command. Each is also printed to stderr as one warning: … line.

FieldTypePresenceDescription
codestringAlwaysMachine-readable kind, for example meeting_provider_unavailable or keywords_ignored_for_plan (create, update, enable), or link_had_upcoming_appointments (delete).
fieldstringOptionalPath of the setting it is about, for example meeting_providers[0].
messagestringAlwaysWhat it means and what to do.

Returned by appointment link delete. It is one flat record, not an envelope: --fields and --excludes apply to these keys.

FieldTypePresenceDescription
deletedbooleanAlwaystrue when the link was deleted; false with --dry-run.
appointment_link_idstringAlwaysThe link's ID.
upcoming_appointmentsintegerAlwaysHow many upcoming appointments (confirmed, starting now or later) the link had. Above 0 only with --keep-appointments: without it such a link is refused with link_has_upcoming_appointments.
warningsAppointment link warning[]Alwayslink_had_upcoming_appointments when upcoming appointments were kept: they stay booked but can no longer be listed or cancelled through Rimo. Also printed to stderr.
dry_runbooleanAlwaystrue with --dry-run: the checks ran and nothing was deleted.

Appointment ​

Returned inside {appointments: [...]} by appointment list, and inside {appointment: {...}, dry_run} by appointment cancel.

FieldTypePresenceDescription
idstringAlwaysThe appointment ID.
appointment_link_idstringAlwaysThe link the appointment was made through.
statusstringAlwaysconfirmed, or cancelled in the result of appointment cancel. appointment list shows confirmed appointments only.
start_atstringAlwaysStart time.
end_atstringAlwaysEnd time.
guest_namestringAlwaysThe guest's name.
guest_emailstringAlwaysThe guest's email address.
guest_messagestringAlwaysThe message the guest left when booking; empty if none.
guest_participantsobject[]AlwaysPeople the guest invited along: name, email.
meeting_urlstringAlwaysThe meeting URL; empty when none was issued.
meeting_providerstringAlwaysThe tool that actually issued meeting_url. It can differ from the link's first choice when that one failed; empty when none was issued.
calendar_providerstringAlwaysgoogle or outlook: the calendar the event was created on.
cancelled_atstring | nullAlwaysWhen the appointment was cancelled; null while it is confirmed, so it is null in appointment list and in a --dry-run cancel.
created_atstringAlwaysWhen the appointment was made.

Search result ​

Returned inside {notes: [...], total_count} by note search. This is a search hit, not a full Note — it carries only what the search index returns.

FieldTypePresenceDescription
idstringAlwaysThe note ID. Pass it to note get.
titlestringOptionalThe note title.
held_atstringOptionalWhen the meeting took place.
created_atstringOptionalWhen the note was created.
owner_namestringOptionalDisplay name of the note's owner. --mode=filter only.
snippetobjectOptionalMatching excerpts. --mode=filter only — see below.

In --mode=filter, total_count is the raw match count before permission filtering — the whole result set rather than the current page, which is what makes --page / --per navigation possible. In --mode=semantic it is the number of unique notes returned.

snippet carries the matching excerpts, with the matched terms wrapped in HTML tags for highlighting. Each key is an array of strings, and all four keys are present — empty arrays where that part of the note did not match.

FieldTypePresenceDescription
transcriptsstring[]AlwaysExcerpts from the transcript.
headingsstring[]AlwaysExcerpts from the note's headings.
annotationsstring[]AlwaysExcerpts from annotations.
document_markdownsstring[]AlwaysExcerpts from the document body.

Authentication responses ​

Login and switch result ​

Returned by auth login (and rimo login) and auth switch. Every field is always present.

FieldTypeDescription
statusstringlogged_in for auth login, switched for auth switch.
aliasstringThe account alias, used with --account.
emailstringThe signed-in email address.
namestringDisplay name, falling back to the email and then the user ID.
orgstringOrganization name, falling back to the org ID and then Personal.

Logout result ​

Returned by auth logout (and rimo logout). Every field is always present.

FieldTypeDescription
statusstringAlways logged_out.
aliasstringThe alias that was logged out.
active_accountstringThe active account after the logout — empty if the one you logged out was active, since there is no auto-promotion.

Auth status ​

Returned by auth status.

FieldTypePresenceDescription
active_accountstringAlwaysAlias of the active account.
accountsobject[]AlwaysEvery saved account — see below.
active_credentialstringOptionalPresent only when an environment variable overrides the configured account: env:RIMO_API_KEY or env:RIMO_TOKEN. When it is present, that credential — not active_account — is what authenticates requests.
api_key_hintstringOptionalMasked form of the key, present only with env:RIMO_API_KEY.

Each entry in accounts:

FieldTypePresenceDescription
aliasstringAlwaysThe account alias, used with --account.
namestringAlwaysDisplay name.
orgstringAlwaysOrganization name.
activebooleanAlwaystrue for the active account.
token_statusstringAlwaysvalid, expiring_soon, expired, or unknown (the expiry could not be determined).
emailstringOptionalThe account's email address.

auth status refreshes any expired or near-expiry token before reporting, so token_status reflects live state rather than what was last written to the credential store.

Plain-text output ​

These commands print plain text on success because a JSON wrapper would only get in the way. Errors are still JSON — see Output & errors.

Note content ​

note get with a content flag prints the note's content directly:

FlagOutput
--transcriptOne line per transcript segment, as Speaker: content. Segments whose speaker could not be resolved print the content alone. Empty segments are skipped.
--documentThe primary document as markdown, preceded by # <title>.
--fullThe transcript, then a blank line, then the primary document. Each attachment the document places is shown where it stands as [<name>](<asset_id> "<summary>"), or ![<name>](<asset_id> "<summary>") for an image (without the title when there is no summary). When the note has attachments the document does not place, a blank line and an ## Attachments section follow: one - <name> (<id>, <size>[, image]) line per attachment, with its summary on the next line (indented two spaces) when it has one.
--document-id <id>One document's markdown, in the same form as --document.
--meeting-chatOne line per web-meeting chat message, as [HH:MM] sender: text. The [HH:MM] and sender: parts are dropped when unavailable, and empty messages are skipped.
--timestampsWith --transcript or --full, prefixes each transcript line with [HH:MM:SS] — time elapsed from the start of the recording, not wall-clock time. A segment with no start time stays unprefixed.

A note with no transcript or no chat messages prints nothing and exits 0.

Attachment ​

note asset get (without --json) prints one attachment as Markdown: # <name>, a - Key: value header (ID, type, size, upload time, analysis status, coverage, pages, document type, language), a quoted note for anything short of a complete result (not analyzed, pending, in progress, not supported, skipped at the note's analyzed-image limit, failed, partial coverage, unread visuals, truncated), then ## Summary when present, and finally ## Content with the extracted text exactly as stored. Nothing follows the content, so it can be cut from the end of the output as is. Terminal control characters (such as the escape character and carriage returns) are removed from this output and from the attachment names and summaries note get --full adds; tabs, newlines and all other text are kept. Use --json for the unaltered values.

Ask answer ​

note ask streams the answer as the model generates it, then a Sources: block — the canonical citation surface, since the answer text carries no inline citations — then a Fetch a note: block. Unusually, all three go to stdout, so this is the one command whose stdout is not machine-readable. See rimo note ask for a full example.

Version and upgrade ​

Both print a single line to stdout — see rimo version and rimo upgrade for the exact strings.

Dry-run output ​

--dry-run on appointment link create is answered by the server: it sends the request with ?dry_run=true, the server resolves and checks it exactly as a real create, and returns the link it would make — your own settings, not placeholders — with "dry_run": true, without saving anything. Its id, url and edit_url are "" because the link does not exist yet; the url to share comes from the real create.

--dry-run on appointment link update works the same way: the server checks the change exactly as a real update and returns the link as it would be after it, with "dry_run": true, without saving. The link already exists, so its id and url are the real ones. appointment link enable and disable with --dry-run do the same for the switch (enable runs its checks too).

--dry-run on appointment link delete also asks the server, which runs the same checks as a real delete — a link with upcoming appointments is still refused with link_has_upcoming_appointments unless --keep-appointments is given — and answers "deleted": false, "dry_run": true without deleting.

--dry-run on appointment cancel asks the server too: it runs the same checks as a real cancel — an appointment that is already cancelled is still refused with appointment_already_cancelled — and returns the appointment as it is now (still confirmed) with "dry_run": true, without cancelling it. The one thing it skips is the calendar: a dry run never contacts it, so it can pass and the real cancel still fail with calendar_event_delete_failed.

--dry-run on the other write commands (note create, note append) sends no request. It returns a representative example of the response shape with "dry_run": true added:

json
{
  "document": { "id": "doc_abc123", "primary": true, "...": "..." },
  "dry_run": true
}

The values are placeholders from the API schema, not a preview of your own input — use it to check the response shape and confirm the command parses, not to see what your note will contain.

--dry-run is rejected on read commands with dry-run not supported for read operations.