> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://murf.ai/api/docs/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://murf.ai/api/docs/_mcp/server.

# AWS Marketplace (SageMaker)

> Subscribe to Murf Finch on AWS Marketplace and deploy it as a SageMaker endpoint in your AWS account. Audio and transcripts stay in your account.

Murf Finch is available on AWS Marketplace as an Amazon SageMaker model package. You subscribe with your AWS account, deploy an endpoint in that account, and call it directly. There is no Murf API key, and no Murf server is in the request path. The container runs with SageMaker network isolation, so audio and transcripts never leave your endpoint. AWS bills you and pays Murf.

The listing has two versions. Finch Global transcribes English and six European languages. Finch Indic transcribes 11 Indian languages plus English (India), and returns word timestamps. Pick the version when you copy the model package ARN. The ARN is different for every version and every Region.

#### [Subscribe on AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-jjx4ovbqssnpq)

Review the offer, accept it, and copy the model package ARN for your version and Region.

#### [GitHub guide and notebook](https://github.com/murf-ai/murf-finch-sagemaker)

Deploy, transcribe a file, stream live audio, run a batch job, and clean up from the sample notebook.

> **Note**
>
> This listing is speech to text only. Text to speech is a separate product: [Falcon 2.1 on AWS Marketplace](/api/docs/text-to-speech/on-premise/aws-marketplace). The hosted [Speech to Text](/api/docs/speech-to-text/overview) API is separate from this page: [stream live audio](/api/docs/speech-to-text/streaming) over a WebSocket, or [upload a file](/api/docs/speech-to-text/file-transcription). Both use a Murf API key. This endpoint uses the SageMaker runtime, and its fields are the ones on this page. A SageMaker batch job is not the hosted file API.

## Versions

| Version      | Languages                                                                                                      | Word timestamps                  | Transcript text           |
| ------------ | -------------------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------------- |
| Finch Global | English, German, Spanish, French, Italian, Portuguese, Dutch                                                   | Empty `words` array              | Lowercase, no punctuation |
| Finch Indic  | Hindi, Bengali, Tamil, Telugu, Marathi, Gujarati, Kannada, Malayalam, Punjabi, Odia, Assamese, English (India) | Start and end time for each word | Punctuated text           |

Each version transcribes only its own languages. Omit the language option and Finch detects the language from the audio. A language code from the other version returns HTTP 400.

## Ways to call the endpoint

| Mode            | API                                     | Use it for                                                                    |
| --------------- | --------------------------------------- | ----------------------------------------------------------------------------- |
| File            | `InvokeEndpoint`                        | One audio file, up to 25 MB                                                   |
| Live stream     | `InvokeEndpointWithBidirectionalStream` | Audio as it is captured. Partials while the speaker talks, one final per turn |
| Batch transform | `CreateTransformJob`                    | A folder of audio files in S3, up to one hour each                            |

## Prerequisites

* **Subscribe.** `AWSMarketplaceManageSubscriptions`, or the `aws-marketplace:ViewSubscriptions`, `Subscribe`, and `Unsubscribe` actions. Nothing is charged until an endpoint or a batch job runs.

* **Deploy.** `AmazonSageMakerFullAccess` on a SageMaker execution role. SageMaker Studio and notebook instances already have a role you can use. To create one:

  ```bash
  aws iam create-role --role-name murf-finch-sagemaker \
    --assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"sagemaker.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
  aws iam attach-role-policy --role-name murf-finch-sagemaker \
    --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
  ```

* **GPU quota.** In Service Quotas → Amazon SageMaker, set `ml.g5.2xlarge for endpoint usage` to at least 1. For batch transform, `ml.g6.2xlarge for transform job usage` is often 0 until you request it. Quota increases can take a day or more.

  ```bash
  aws service-quotas list-service-quotas --service-code sagemaker --region us-east-1 \
    --query "Quotas[?contains(QuotaName,'ml.g5.2xlarge for endpoint usage')].[QuotaName,Value]"
  ```

* **Live streaming from Python.** Python 3.12+ and `aws-sdk-sagemaker-runtime-http2[awscrt]>=0.11`. boto3 does not support the bidirectional API.

## Quickstart

About 15 minutes, most of it waiting for the endpoint to start. The [notebook](https://github.com/murf-ai/murf-finch-sagemaker/blob/main/Murf-Finch-STT-on-SageMaker.ipynb) does the same steps. It reads an ARN for the notebook's Region from `model_packages.json` when that Region is listed there. For any other Region, or to pin a version, paste the ARN from the listing into `MODEL_PACKAGE_ARN`.

#### Subscribe and copy the ARN

Open the [listing](https://aws.amazon.com/marketplace/pp/prodview-jjx4ovbqssnpq), choose **Continue to subscribe**, review pricing and the EULA, then **Accept offer**. Choose **Continue to configuration**, pick Finch Global or Finch Indic and your Region, and copy the product ARN.

Already subscribed? AWS Marketplace → **Manage subscriptions** → Murf Finch → **Launch new configuration**, select the version and Region, and copy the ARN.

#### Deploy the endpoint

Network isolation is required for Marketplace model packages. The startup health check needs 900 seconds because the model takes a few minutes to load. Least-outstanding-requests routing sends each new stream to the least busy instance once you run more than one.

```python
import boto3, time

region = "us-east-1"  # the Region you copied the ARN for
model_package_arn = "<model package ARN from the listing>"
role = "arn:aws:iam::<account-id>:role/murf-finch-sagemaker"
name = f"murf-finch-{time.strftime('%Y%m%d-%H%M%S')}"

sm = boto3.client("sagemaker", region_name=region)
sm.create_model(
    ModelName=name,
    ExecutionRoleArn=role,
    PrimaryContainer={"ModelPackageName": model_package_arn},
    EnableNetworkIsolation=True,
)
sm.create_endpoint_config(
    EndpointConfigName=name,
    ProductionVariants=[{
        "VariantName": "AllTraffic",
        "ModelName": name,
        "InstanceType": "ml.g5.2xlarge",
        "InitialInstanceCount": 1,
        "ContainerStartupHealthCheckTimeoutInSeconds": 900,
        "RoutingConfig": {"RoutingStrategy": "LEAST_OUTSTANDING_REQUESTS"},
    }],
)
sm.create_endpoint(EndpointName=name, EndpointConfigName=name)
sm.get_waiter("endpoint_in_service").wait(
    EndpointName=name, WaiterConfig={"Delay": 30, "MaxAttempts": 80}
)
```

The endpoint is ready in about 8–10 minutes. `describe_model_package` and `create_model` fail when the account is not subscribed to that version.

#### Transcribe a file

The body is the audio file. [`samples/en_us_sample.wav`](https://github.com/murf-ai/murf-finch-sagemaker/blob/main/samples/en_us_sample.wav) is an English clip for Finch Global, and [`samples/hi_in_sample.wav`](https://github.com/murf-ai/murf-finch-sagemaker/blob/main/samples/hi_in_sample.wav) is Hindi for Finch Indic. Both are from the FLEURS dataset (CC BY 4.0).

```python
import json

runtime = boto3.client("sagemaker-runtime", region_name=region)
resp = runtime.invoke_endpoint(
    EndpointName=name,
    ContentType="audio/wav",
    Body=open("en_us_sample.wav", "rb").read(),
)
print(json.loads(resp["Body"].read())["text"])
```

Or from a terminal, with the endpoint name in `NAME`:

```bash
aws sagemaker-runtime invoke-endpoint --endpoint-name "$NAME" \
  --content-type audio/wav --body fileb://samples/en_us_sample.wav out.json && cat out.json
```

#### Delete the endpoint when you are done

> **Warning**
>
> You pay AWS for the GPU instance while the endpoint exists, whether or not you send requests. Delete test endpoints when you finish.

```python
sm.delete_endpoint(EndpointName=name)
sm.delete_endpoint_config(EndpointConfigName=name)
sm.delete_model(ModelName=name)
```

The subscription stays active, so you can deploy again later. To end it, delete your models first, then cancel under AWS Marketplace → **Manage subscriptions**.

## Transcribe a file

`InvokeEndpoint` returns the full transcript. WAV, FLAC, MP3, OGG/Opus, M4A, and other common formats are accepted. A request can be up to 25 MB (about 13 minutes of 16 kHz WAV, and longer for MP3 or Opus) and must finish within SageMaker's 60-second limit. Longer files use [batch transform](#batch-transform).

`Content-Type` is `audio/wav`, `audio/mpeg`, `application/octet-stream`, or the type that matches the file.

Options go in the `X-Amzn-SageMaker-Custom-Attributes` header (`CustomAttributes` in boto3, `--custom-attributes` in the CLI) as comma-separated `key=value` pairs. They are not fields in a JSON body.

| Option                   | Required | Description                                                                                                                       |
| ------------------------ | -------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `language_code`          | No       | Language of the audio, such as `en` or `de` on Finch Global and `hi` on Finch Indic. Detected when omitted.                       |
| `timestamps_granularity` | No       | `word` (default) or `none`. Finch Indic returns word start and end times. Finch Global returns an empty `words` array either way. |
| `keyterms`               | No       | Words or phrases to recognize more reliably. Separate phrases with a vertical bar.                                                |

```python
resp = runtime.invoke_endpoint(
    EndpointName=name,
    ContentType="audio/wav",
    CustomAttributes="language_code=hi,timestamps_granularity=word,keyterms=Murf|Finch",
    Body=open("hi_in_sample.wav", "rb").read(),
)
```

### Response

Every response includes these fields:

| Field                  | Description                                                                                                                                  |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `text`                 | The transcript. Finch Global is lowercase and has no punctuation.                                                                            |
| `language_code`        | Detected or requested language.                                                                                                              |
| `language_probability` | Confidence of the language detection, from 0 to 1.                                                                                           |
| `words`                | Finch Indic: each word as `text`, `start`, `end` (seconds), and `type`. Empty for Finch Global, and when `timestamps_granularity` is `none`. |
| `audio_duration_secs`  | Length of the audio. This is the billed duration.                                                                                            |
| `transcription_id`     | Unique ID. Include it in support requests.                                                                                                   |

```json
{
  "transcription_id": "88167718-7e7a-4529-992c-2aee87b56a04",
  "language_code": "en",
  "language_probability": 1.0,
  "text": "he did not set a figure for the cuts saying they would be made based on china's economic output",
  "words": [],
  "audio_duration_secs": 6.36
}
```

A Finch Indic word looks like this:

```json
{"text": "यह", "start": 0.788, "end": 0.958, "type": "word"}
```

## Stream live audio

Open a bidirectional stream with [`InvokeEndpointWithBidirectionalStream`](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithBidirectionalStream.html). [`examples/stream.py`](https://github.com/murf-ai/murf-finch-sagemaker/blob/main/examples/stream.py) is a complete Python client. It uses `AWSCRTHTTPClient` against the runtime endpoint on port 8443. Another transport raises `UnsupportedTransportError`.

```bash
pip install "aws-sdk-sagemaker-runtime-http2[awscrt]>=0.11" boto3
python examples/stream.py --endpoint "$NAME" --region "$AWS_REGION" samples/en_us_sample.wav
```

`--language de` sets the language, `--bvc` suppresses background voices, and `--raw` prints every message.

Options go in `ModelQueryString`, for example `language=hi&keywords=Murf,Finch`. Names here differ from a file request: the query uses `language` and `keywords`. The file header uses `language_code` and `keyterms`.

| Option                       | Description                                                                                                                               |
| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `language`                   | One code (`en`, `hi`, `de`), or a comma-separated set to detect from. Detected when omitted.                                              |
| `keywords`                   | Comma-separated words or phrases to recognize more reliably.                                                                              |
| `commit_mode`                | `vad` (default) ends a turn after a short silence. `manual` ends a turn only when you send `Finalize`.                                    |
| `vad_silence_threshold_secs` | Silence that ends a turn in `vad` mode. Default 0.55, range 0.192 to 3.0. Raise it for slow speakers, lower it for snappier agents.       |
| `bvc`                        | `true` suppresses background voices, such as a TV or people nearby. Off by default. The capacity figures below were measured with it off. |

**You send:**

1. Optionally, one JSON text message describing the audio. Without it the endpoint expects 16-bit little-endian mono PCM at 16 kHz.

   ```json
   {"type": "AudioConfig", "codec": "pcm_s16le", "sample_rate": 16000, "channels": 1}
   ```

   `codec` is `pcm_s16le`, `mulaw`, `alaw`, or `opus` (one packet per frame). `sample_rate` is 8000, 12000, 16000, 24000, 32000, 44100, or 48000.

2. Audio as binary frames, ideally 20–100 ms each, at real-time pace.

3. Control messages as JSON text. `Finalize` ends the current turn and keeps the stream open. `CloseStream` flushes and closes. `KeepAlive` holds a paused stream open; send it instead of silence.

   ```json
   {"type": "Finalize"}
   ```

**You receive** JSON text messages:

```json
{"type": "SessionStarted", "session_id": "20261112T103817Z_05a4...", "language": null}
```

```json
{"type": "partial", "transcript": "he did not set a figure", "rawEvent": {"event": "Update", "turn_index": 0}}
```

```json
{
  "type": "final",
  "transcript": "he did not set a figure for the cuts saying they will be made based on china's economic output",
  "rawEvent": {
    "event": "EndOfTurn",
    "turn_index": 0,
    "audio_window_start": 0.916,
    "audio_window_end": 5.26,
    "language": "en",
    "language_confidence": 1.0,
    "words": []
  }
}
```

* `partial` updates the current turn as the speaker talks. Show it as live captions.
* One `final` per turn carries the settled text. A `final` with an empty transcript means the turn contained no speech.
* `rawEvent` adds timing in seconds from the start of the stream, the detected language, and, on Finch Indic, word timestamps.
* The transcript field on a stream is `transcript`. A file response uses `text`.
* Errors arrive as a message with `"type": "Error"` and a `message` string.

A stream closes after 10 seconds without a first message, or after 180 seconds without audio or `KeepAlive`.

## Batch transform

Put one audio file per S3 object under an input prefix. Each output object is the input name plus `.out` and holds the same JSON as a real-time response. Files can be up to one hour long.

```bash
aws sagemaker create-transform-job --transform-job-name finch-batch-1 --model-name "$NAME" \
  --transform-input '{"DataSource":{"S3DataSource":{"S3DataType":"S3Prefix","S3Uri":"s3://my-bucket/audio/"}},"ContentType":"audio/wav","SplitType":"None"}' \
  --transform-output '{"S3OutputPath":"s3://my-bucket/transcripts/","Accept":"application/json"}' \
  --transform-resources '{"InstanceType":"ml.g6.2xlarge","InstanceCount":1}' \
  --max-payload-in-mb 100 --batch-strategy SingleRecord
```

`SplitType` `None` keeps each object as one audio file. Batch transform runs on `ml.g6.2xlarge`, `ml.g6.xlarge`, and `ml.g5.xlarge`, and needs "for transform job usage" quota for that type. The [notebook](https://github.com/murf-ai/murf-finch-sagemaker/blob/main/Murf-Finch-STT-on-SageMaker.ipynb) uploads the sample clips and prints each transcript.

## Instances and performance

Measured on Amazon SageMaker in us-east-2 in November 2026. Live 16 kHz streams of FLEURS speech were sent at real-time pace, 120 seconds per load level. "Streams" is the highest load tested at which 90% of final transcripts arrived within 250 ms of the end of speech. The stream counts are for Finch Global. Finch Indic stayed under 165 ms (p90) at 64 streams on every instance below. A single stream is 45–85 ms (p90) on all of them.

| Instance                      | GPU         | Live streams | Final transcript, p90 | Best for                  |
| ----------------------------- | ----------- | ------------ | --------------------- | ------------------------- |
| `ml.g5.2xlarge` (recommended) | NVIDIA A10G | 96           | 222 ms                | Lowest cost per stream    |
| `ml.g6.xlarge`                | NVIDIA L4   | 64           | 217 ms                | Lowest price per instance |
| `ml.g6.2xlarge`               | NVIDIA L4   | 64           | 204 ms                |                           |
| `ml.g5.xlarge`                | NVIDIA A10G | 64           | 143 ms                |                           |
| `ml.g6e.xlarge`               | NVIDIA L40S | 96           | 90 ms                 | Lowest latency            |

On one `ml.g5.2xlarge`, p90 final latency is 66 ms at 1 stream, 106 ms at 32, 150 ms at 64, and 222 ms at 96.

Size the endpoint as peak concurrent streams divided by streams per instance, rounded up, plus one instance for redundancy. For variable traffic, add [SageMaker auto scaling](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html) on `ConcurrentRequestsPerModel`.

Other instance types are not supported in this version. `ml.g4dn` is too slow for live use, and `ml.g7e` does not start.

When a GPU type is unavailable in an Availability Zone, give the endpoint a fallback list with [instance pools](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deploy-models.html). Replace `InstanceType` in the production variant with:

```json
"InstancePools": [
  {"InstanceType": "ml.g5.2xlarge", "Priority": 1},
  {"InstanceType": "ml.g6.xlarge", "Priority": 2},
  {"InstanceType": "ml.g6.2xlarge", "Priority": 3}
],
"VariantInstanceProvisionTimeoutInSeconds": 300
```

Every type in the pool needs quota of at least 1.

### Accuracy

Word error rate on the FLEURS test sets, with text normalized before scoring:

| Language                | WER   | Language             | WER  |
| ----------------------- | ----- | -------------------- | ---- |
| English (US)            | 5.2%  | Italian              | 3.4% |
| German                  | 5.5%  | Dutch                | 6.5% |
| Spanish (Latin America) | 2.6%  | Portuguese (Brazil)  | 5.6% |
| French                  | 5.5%  | Finch Global average | 4.9% |
| Hindi (Finch Indic)     | 10.3% |                      |      |

Accuracy is lower on noisy, overlapping, or far-field speech. Test with your own audio.

## Limitations

* Speaker diarization is not included.
* Finch Global returns lowercase text without punctuation, and its `words` array is empty.
* Each version transcribes only the languages in the [versions](#versions) table.

## Pricing

Real-time and streaming usage is billed per minute of audio, in fractions of a minute. Streams of PCM, mu-law, or A-law are billed by the audio duration sent. Opus streams are billed by session time. Pauses covered by `KeepAlive` are not billed for PCM streams. For a file request, `audio_duration_secs` is the billed duration.

Batch transform is billed per instance-hour while the job runs. AWS separately bills the SageMaker instance hours. Current prices are on the [listing](https://aws.amazon.com/marketplace/pp/prodview-jjx4ovbqssnpq).

## Troubleshooting

| Symptom                                                             | Fix                                                                                                                                        |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `ResourceLimitExceeded` when creating the endpoint or transform job | Request a quota increase for that instance type, or use another type from the table above.                                                 |
| Endpoint `Failed` with `InsufficientInstanceCapacity`               | AWS has no free GPUs of that type in the Region right now. Retry, use an instance pool, or another Region.                                 |
| Endpoint fails its health check                                     | Keep `ContainerStartupHealthCheckTimeoutInSeconds` at 900, and use a supported instance type. `ml.g4dn` and `ml.g7e` are not supported.    |
| `ValidationError` mentioning network isolation                      | Create the model with `EnableNetworkIsolation` set to true.                                                                                |
| HTTP 413 on `InvokeEndpoint`                                        | The file is over 25 MB. Compress it, split it, or use batch transform.                                                                     |
| `ModelError` with status 400                                        | The audio could not be decoded, or `language_code` is not in this version. The message says which.                                         |
| Stream fails with `UnsupportedTransportError`                       | Use `smithy_http.aio.crt.AWSCRTHTTPClient` as the transport, as in `examples/stream.py`.                                                   |
| Stream returns nothing                                              | The audio format does not match `AudioConfig`. The default is 16 kHz 16-bit mono PCM. Silence produces an empty final transcript.          |
| Transcript in the wrong language                                    | Set `language_code` on a file, or `language` on a stream. Finch Global does not transcribe Indian languages. Deploy Finch Indic for those. |

## Security and privacy

* Audio and transcripts stay in your account. With network isolation, the container has no network access and sends nothing to Murf or any third party.
* Audio and transcripts are not used to train models.
* The endpoint writes one line per request to CloudWatch Logs with status and timing. Audio and transcript text are never logged.

## Support

Murf cannot see your requests, audio, or transcripts. Email [support@murf.ai](mailto:support@murf.ai) with the AWS Region, instance type, listing version, the `transcription_id` or `session_id`, and the error message. Billing disputes go through AWS Marketplace.

#### [Email](mailto:support@murf.ai)

[support@murf.ai](mailto:support@murf.ai)

#### [Contact Sales](https://murf.ai/enterprise?src=d_contact_sales_api_docs)

Private offers and custom terms