Status Operations

Complete status (toot) management including posting, editing, and interactions.

Types

Status

type Status struct {
    ID                 ID
    URI                string
    URL                string
    Account            Account
    InReplyToID        interface{}
    InReplyToAccountID interface{}
    Reblog             *Status
    Content            string
    CreatedAt          time.Time
    EditedAt           *time.Time
    Emojis             []Emoji
    RepliesCount       int64
    ReblogsCount       int64
    FavouritesCount    int64
    Reblogged          bool
    Favourited         bool
    Bookmarked         bool
    Muted              bool
    Sensitive          bool
    SpoilerText        string
    Visibility         string
    MediaAttachments   []Attachment
    Mentions           []Mention
    Tags               []Tag
    Card               *Card
    Poll               *Poll
    Application        *Application
    Language           *string
    Pinned             bool
    ScheduledParams    *ScheduledParams
    Filtered           []FilterResult
}

Status represents a toot/post on Mastodon.

Fields:

• ID - Unique status identifier
• URI - ActivityPub URI
• URL - Web URL for the status
• Account - Author's account
• InReplyToID - ID of status this replies to (if any)
• InReplyToAccountID - ID of account this replies to
• Reblog - Reblogged status (if this is a reblog)
• Content - HTML content of status
• CreatedAt - Creation timestamp
• EditedAt - Last edit timestamp (nil if not edited)
• Emojis - Custom emojis used in content
• RepliesCount - Number of replies
• ReblogsCount - Number of reblogs/boosts
• FavouritesCount - Number of favourites/likes
• Reblogged - Whether current user reblogged
• Favourited - Whether current user favourited
• Bookmarked - Whether current user bookmarked
• Muted - Whether current user muted conversation
• Sensitive - Whether media is marked sensitive
• SpoilerText - Content warning text
• Visibility - Visibility level ("public", "unlisted", "private", "direct")
• MediaAttachments - Attached media files
• Mentions - Mentioned accounts
• Tags - Hashtags used
• Card - Preview card for links
• Poll - Attached poll
• Application - Application used to post
• Language - Language code
• Pinned - Whether status is pinned to profile
• ScheduledParams - Scheduling parameters (if scheduled)
• Filtered - Filter results applied to this status

Toot

type Toot struct {
    Status      string
    InReplyToID ID
    MediaIDs    []ID
    Sensitive   bool
    SpoilerText string
    Visibility  string
    Language    string
    ScheduledAt *time.Time
    Poll        *TootPoll
}

Toot is a struct for posting or updating a status.

Fields:

• Status - Text content of the status
• InReplyToID - ID of status to reply to
• MediaIDs - IDs of media attachments
• Sensitive - Mark media as sensitive
• SpoilerText - Content warning text
• Visibility - Visibility level (use constants)
• Language - Language code (e.g., "en", "ja")
• ScheduledAt - Schedule status for future posting
• Poll - Poll to attach

TootPoll

type TootPoll struct {
    Options          []string
    ExpiresInSeconds int
    Multiple         bool
    HideTotals       bool
}

TootPoll holds information for creating a poll in a toot.

Fields:

• Options - Poll option strings (2-4 options)
• ExpiresInSeconds - Poll duration in seconds
• Multiple - Allow multiple choice selection
• HideTotals - Hide vote counts until poll expires

StatusHistory

type StatusHistory struct {
    Content          string
    SpoilerText      string
    Account          Account
    Sensitive        bool
    CreatedAt        time.Time
    Emojis           []Emoji
    MediaAttachments []Attachment
}

StatusHistory represents a single edit in a status's edit history.

Fields:

• Content - HTML content at this version
• SpoilerText - Content warning at this version
• Account - Account information (unchanged)
• Sensitive - Sensitive flag at this version
• CreatedAt - Timestamp of this edit
• Emojis - Custom emojis used
• MediaAttachments - Media attachments at this version

Context

type Context struct {
    Ancestors   []*Status
    Descendants []*Status
}

Context holds the conversation thread for a status.

Fields:

• Ancestors - Statuses before this one in thread (oldest first)
• Descendants - Statuses after this one in thread (newest first)

Card

type Card struct {
    URL          string
    Title        string
    Description  string
    Image        string
    Type         string
    AuthorName   string
    AuthorURL    string
    ProviderName string
    ProviderURL  string
    HTML         string
    Width        int64
    Height       int64
}

Card represents a preview card for links in statuses.

Fields:

• URL - URL being previewed
• Title - Page title
• Description - Page description
• Image - Preview image URL
• Type - Card type ("link", "photo", "video", "rich")
• AuthorName - Content author name
• AuthorURL - Content author URL
• ProviderName - Provider name (e.g., "YouTube")
• ProviderURL - Provider URL
• HTML - HTML for embedded content
• Width - Embedded content width
• Height - Embedded content height

Source

type Source struct {
    ID          ID
    Text        string
    SpoilerText string
}

Source holds source data for editing a status.

Fields:

• ID - Status ID
• Text - Plain text content (for editing)
• SpoilerText - Plain text content warning

ScheduledParams

type ScheduledParams struct {
    ApplicationID ID
    Idempotency   string
    InReplyToID   interface{}
    MediaIDs      []ID
    Poll          *Poll
    ScheduledAt   *time.Time
    Sensitive     bool
    SpoilerText   string
    Text          string
    Visibility    string
}

ScheduledParams holds parameters for scheduled statuses.

Fields:

• ApplicationID - Application that created this
• Idempotency - Idempotency key
• InReplyToID - Reply target ID
• MediaIDs - Media attachment IDs
• Poll - Poll data
• ScheduledAt - Scheduled posting time
• Sensitive - Sensitive media flag
• SpoilerText - Content warning
• Text - Status text
• Visibility - Visibility setting

Constants

Visibility Constants

const (
    VisibilityPublic        = "public"
    VisibilityUnlisted      = "unlisted"
    VisibilityFollowersOnly = "private"
    VisibilityDirectMessage = "direct"
)

Convenience constants for Toot.Visibility field.

• VisibilityPublic - Visible to all, appears in public timelines
• VisibilityUnlisted - Visible to all, does not appear in public timelines
• VisibilityFollowersOnly - Visible only to followers
• VisibilityDirectMessage - Visible only to mentioned users

Status Management

PostStatus { .api }

func (c *Client) PostStatus(ctx context.Context, toot *Toot) (*Status, error)

Posts a new status.

Parameters:

• ctx - Context for cancellation/timeout
• toot - Toot configuration with content and options

Returns: Created Status or error

Example:

toot := &mastodon.Toot{
    Status:     "Hello, Mastodon!",
    Visibility: mastodon.VisibilityPublic,
}
status, err := client.PostStatus(ctx, toot)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Posted: %s\n", status.URL)

UpdateStatus { .api }

func (c *Client) UpdateStatus(ctx context.Context, toot *Toot, id ID) (*Status, error)

Updates an existing status (edits it).

Parameters:

• ctx - Context for cancellation/timeout
• toot - New status content
• id - ID of status to update

Returns: Updated Status or error

Example:

toot := &mastodon.Toot{
    Status: "Updated content",
}
status, err := client.UpdateStatus(ctx, toot, "123456")
if err != nil {
    log.Fatal(err)
}

DeleteStatus { .api }

func (c *Client) DeleteStatus(ctx context.Context, id ID) error

Deletes a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID to delete

Returns: Error if operation fails

GetStatus { .api }

func (c *Client) GetStatus(ctx context.Context, id ID) (*Status, error)

Returns status by ID.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID to retrieve

Returns: Status or error

GetStatusContext { .api }

func (c *Client) GetStatusContext(ctx context.Context, id ID) (*Context, error)

Returns the conversation context (thread) for a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID

Returns: Context with ancestors and descendants or error

Example:

context, err := client.GetStatusContext(ctx, "123456")
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Thread has %d ancestors and %d descendants\n",
    len(context.Ancestors), len(context.Descendants))

GetStatusCard { .api }

func (c *Client) GetStatusCard(ctx context.Context, id ID) (*Card, error)

Returns the preview card for a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID

Returns: Card or error

GetStatusSource { .api }

func (c *Client) GetStatusSource(ctx context.Context, id ID) (*Source, error)

Returns the source data for editing a status (plain text version).

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID

Returns: Source with plain text or error

GetStatusHistory { .api }

func (c *Client) GetStatusHistory(ctx context.Context, id ID) ([]*StatusHistory, error)

Returns the edit history of a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID

Returns: Slice of StatusHistory entries (newest first) or error

Interactions

Reblog { .api }

func (c *Client) Reblog(ctx context.Context, id ID) (*Status, error)

Reblogs (boosts) a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID to reblog

Returns: Reblog Status or error

Unreblog { .api }

func (c *Client) Unreblog(ctx context.Context, id ID) (*Status, error)

Unreblogs a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID to unreblog

Returns: Original Status or error

Favourite { .api }

func (c *Client) Favourite(ctx context.Context, id ID) (*Status, error)

Favourites (likes) a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID to favourite

Returns: Updated Status or error

Unfavourite { .api }

func (c *Client) Unfavourite(ctx context.Context, id ID) (*Status, error)

Unfavourites a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID to unfavourite

Returns: Updated Status or error

Bookmark { .api }

func (c *Client) Bookmark(ctx context.Context, id ID) (*Status, error)

Bookmarks a status (private save).

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID to bookmark

Returns: Updated Status or error

Unbookmark { .api }

func (c *Client) Unbookmark(ctx context.Context, id ID) (*Status, error)

Unbookmarks a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID to unbookmark

Returns: Updated Status or error

Interaction Lists

GetRebloggedBy { .api }

func (c *Client) GetRebloggedBy(ctx context.Context, id ID, pg *Pagination) ([]*Account, error)

Returns accounts that reblogged a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID
• pg - Pagination parameters (optional)

Returns: Slice of Account objects or error

GetFavouritedBy { .api }

func (c *Client) GetFavouritedBy(ctx context.Context, id ID, pg *Pagination) ([]*Account, error)

Returns accounts that favourited a status.

Parameters:

• ctx - Context for cancellation/timeout
• id - Status ID
• pg - Pagination parameters (optional)

Returns: Slice of Account objects or error

GetFavourites { .api }

func (c *Client) GetFavourites(ctx context.Context, pg *Pagination) ([]*Status, error)

Returns the current user's favourited statuses.

Parameters:

• ctx - Context for cancellation/timeout
• pg - Pagination parameters (optional)

Returns: Slice of favourited Status objects or error

GetBookmarks { .api }

func (c *Client) GetBookmarks(ctx context.Context, pg *Pagination) ([]*Status, error)

Returns the current user's bookmarked statuses.

Parameters:

• ctx - Context for cancellation/timeout
• pg - Pagination parameters (optional)

Returns: Slice of bookmarked Status objects or error

Example: Posting with Poll

poll := &mastodon.TootPoll{
    Options:          []string{"Option A", "Option B", "Option C"},
    ExpiresInSeconds: 86400, // 24 hours
    Multiple:         false,
}

toot := &mastodon.Toot{
    Status:     "What's your favorite?",
    Visibility: mastodon.VisibilityPublic,
    Poll:       poll,
}

status, err := client.PostStatus(ctx, toot)
if err != nil {
    log.Fatal(err)
}

Example: Replying to Status

toot := &mastodon.Toot{
    Status:      "@username Great point!",
    InReplyToID: "123456", // ID of status to reply to
    Visibility:  mastodon.VisibilityPublic,
}

reply, err := client.PostStatus(ctx, toot)
if err != nil {
    log.Fatal(err)
}

Example: Scheduled Post

schedTime := time.Now().Add(24 * time.Hour)

toot := &mastodon.Toot{
    Status:      "This will post tomorrow!",
    Visibility:  mastodon.VisibilityPublic,
    ScheduledAt: &schedTime,
}

status, err := client.PostStatus(ctx, toot)

Related Types

See also:

• Accounts - For account information
• Media - For media attachments
• Polls - For poll operations
• Timelines - For timeline retrieval
• Types - For common types