Audio Message

Send voice recordings and audio content with automatic processing, format optimization, and cross-platform compatibility

Send an audio message (MP3 or WAV, up to 1 GB) to a channel. Mobile SDKs handle upload automatically, while web SDKs require a separate upload step before sending.

Audio Messaging Overview

Audio messages allow users to convey tone and detail that text cannot capture: voice notes, recordings, and spoken explanations.

Voice Expression

Voice communication

• Convey tone and emotion naturally
• Quick voice notes and responses
• Detailed audio explanations
• Personal touch in conversations

Format Support

Audio handling

• MP3 and WAV format support
• Up to 1GB file size capacity
• Cross-platform compatibility

Platform Implementation

Mobile SDKs (iOS/Android)

Unified audio handling with automatic upload

Mobile SDKs provide streamlined audio messaging with automatic upload processing, eliminating the need for separate upload steps.

Required Parameters

Parameter	Type	Description
subChannelId	String	Target subchannel identifier for the audio message
attachment	Audio/URI	Local audio file path or URI reference

Optional Parameters

Parameter	Type	Description
caption	String	Text description or transcript for the audio
fileName	String	Custom filename for the uploaded audio
tags	Array<String>	Message categorization and filtering tags
parentId	String	Parent message ID for threaded conversations
metadata	Object	Custom properties for extended functionality

Implementation Examples

iOS

// Create audio message with local file
let audioUrl = URL(fileURLWithPath: "/path/to/local/audio.mp3")
let options = AmityAudioMessageCreateOptions(
    subChannelId: "subChannel-123",
    attachment: .localURL(url: audioUrl),
    fileName: "voice_note.mp3",
    tags: ["voice-note", "quick-update"],
    parentId: nil
)

do {
    let message = try await messageRepository.createAudioMessage(options: options)
    print("Audio message sent: \(message.messageId)")
    
    // Access audio details
    if let audioData = message.data as? AmityMessageAudioData {
        print("Audio duration: \(audioData.duration) seconds")
        print("File size: \(audioData.fileSize) bytes")
    }
} catch {
    // Handle upload or creation error
    print("Failed to send audio: \(error)")
}

Automatic Processing: Mobile SDKs handle audio upload and format optimization automatically, providing seamless user experience with progress tracking.

TypeScript SDK

Two-step process with manual upload control

TypeScript SDK requires explicit audio upload before message creation, providing detailed control over the upload process and file handling.

Upload Process Flow

1. Upload Audio: Use FileRepository to upload audio and get fileId
2. Create Message: Use fileId to create audio message
3. Handle Response: Process message creation and audio metadata

Implementation Example

TypeScript

import { 
  MessageRepository, 
  FileRepository, 
  MessageContentType 
} from '@amityco/ts-sdk';

// Complete audio message creation process
async function createAudioMessage(subChannelId: string, audioFile: File) {
  try {
    // Step 1: Upload audio file
    const formData = new FormData();
    formData.append('files', audioFile);

    console.log('Starting audio upload...');
    const { data: uploadedFiles } = await FileRepository.uploadFile(formData);
    const { fileId, fileName, fileSize } = uploadedFiles[0];

    // Step 2: Create audio message with uploaded file
    const audioMessage = {
      subChannelId: subChannelId,
      dataType: MessageContentType.AUDIO,
      fileId: fileId,
      caption: 'Voice message with important project updates 🎵',
      tags: ['voice-message', 'project-update', 'important'],
      metadata: {
        audio: {
          original_name: audioFile.name,
          file_size: audioFile.size,
          format: audioFile.name.split('.').pop()?.toLowerCase(),
          uploaded_at: new Date().toISOString()
        },
        content: {
          type: 'voice_message',
          category: 'project_communication',
          urgency: 'normal',
          transcription_available: false
        },
        technical: {
          upload_method: 'web_browser',
          compression_applied: false,
          quality: 'original'
        }
      }
    };

    // Step 3: Send the message
    const { data: message } = await MessageRepository.createMessage(audioMessage);
    console.log('Audio message created:', message.messageId);
    return message;

  } catch (error) {
    console.error('Failed to create audio message:', error);
    throw error;
  }
}

Upload Parameters

Parameter	Type	Description
files	FormData	Audio file(s) to upload (MP3, WAV formats)

Message Parameters

Parameter	Type	Description
subChannelId	String	Target subchannel for the message
dataType	MessageContentType	Set to MessageContentType.AUDIO
fileId	String	File ID returned from upload operation
caption	String	Optional audio caption or transcript

Format Validation: Only MP3 and WAV formats are supported. Files cannot exceed 1GB in size. Always validate format and size before upload.

Audio Message Features

Audio Formats & Quality

Comprehensive audio format support and quality options

Supported Formats

• MP3: Universal compatibility, excellent compression, ideal for voice and music
• WAV: Uncompressed quality, perfect for high-fidelity recordings
• Format Conversion: Automatic optimization for web delivery when needed

Quality Options

• Voice Optimized: 64-128kbps for clear voice recordings
• Standard Quality: 128-192kbps for general audio content
• High Quality: 256-320kbps for music and detailed audio

Related Features

Video Messages

Video content Share video recordings and visual content

File Messages

Document sharing Send files, documents, and attachments

Implementation Strategy: Start with basic audio messaging using platform-specific patterns (unified upload for mobile, two-step for web), then add recording capabilities, transcription features, and advanced metadata. Always validate audio formats and implement proper progress feedback for optimal user experience.