Pre-Recorded Audio Quickstart

# Install the Deepgram Python SDK
# https://github.com/deepgram/deepgram-python-sdk
pip install deepgram-sdk

# Initialize a new application
npm init

# Install the Deepgram Node.js SDK
# https://github.com/deepgram/node-sdk
npm install @deepgram/sdk

# Install the Deepgram .NET SDK
# https://github.com/deepgram/deepgram-dotnet-sdk
dotnet add package Deepgram

# Install the Deepgram Go SDK
go get github.com/deepgram-devs/deepgram-go-sdk

# Example filename: deepgram_test.py

from deepgram import Deepgram
import asyncio, json

# Your Deepgram API Key
DEEPGRAM_API_KEY = 'YOUR_DEEPGRAM_API_KEY'

# Location of the file you want to transcribe. Should include filename and extension.
# Example of a local file: ../../Audio/life-moves-pretty-fast.wav
# Example of a remote file: https://static.deepgram.com/examples/interview_speech-analytics.wav
FILE = 'YOUR_FILE_LOCATION'

# Mimetype for the file you want to transcribe
# Include this line only if transcribing a local file
# Example: audio/wav
MIMETYPE = 'YOUR_FILE_MIME_TYPE'

async def main():

  # Initialize the Deepgram SDK
  deepgram = Deepgram(DEEPGRAM_API_KEY)

  # Check whether requested file is local or remote, and prepare source
  if FILE.startswith('http'):
    # file is remote
    # Set the source
    source = {
      'url': FILE
    }
  else:
    # file is local
    # Open the audio file
    audio = open(FILE, 'rb')

    # Set the source
    source = {
      'buffer': audio,
      'mimetype': MIMETYPE
    }

  # Send the audio to Deepgram and get the response
  response = await asyncio.create_task(
    deepgram.transcription.prerecorded(
      source,
      {
        'smart_format': True,
        'model': 'nova',
      }
    )
  )

  # Write the response to the console
  print(json.dumps(response, indent=4))

  # Write only the transcript to the console
  #print(response["results"]["channels"][0]["alternatives"][0]["transcript"])

try:
  # If running in a Jupyter notebook, Jupyter is already running an event loop, so run main with this line instead:
  #await main()
  asyncio.run(main())
except Exception as e:
  exception_type, exception_object, exception_traceback = sys.exc_info()
  line_number = exception_traceback.tb_lineno
  print(f'line {line_number}: {exception_type} - {e}')

// Example filename: index.js

const fs = require("fs");
const { Deepgram } = require("@deepgram/sdk");

// Your Deepgram API Key
const deepgramApiKey = "YOUR_DEEPGRAM_API_KEY";

// Location of the file you want to transcribe. Should include filename and extension.
// Example of a local file: ../../Audio/life-moves-pretty-fast.wav
// Example of a remote file: https://static.deepgram.com/examples/interview_speech-analytics.wav
const file = "YOUR_FILE_LOCATION";

// Mimetype for the file you want to transcribe
// Only necessary if transcribing a local file
// Example: audio/wav
const mimetype = "YOUR_FILE_MIME_TYPE";

// Initialize the Deepgram SDK
const deepgram = new Deepgram(deepgramApiKey);

// Check whether requested file is local or remote, and prepare accordingly
if (file.startsWith("http")) {
	// File is remote
	// Set the source
	source = {
		url: file,
	};
} else {
	// File is local
	// Open the audio file
	const audio = fs.readFileSync(file);

	// Set the source
	source = {
		buffer: audio,
		mimetype: mimetype,
	};
}

// Send the audio to Deepgram and get the response
deepgram.transcription
	.preRecorded(source, {
		smart_format: true,
		model: "nova",
	})
	.then((response) => {
		// Write the response to the console
		console.dir(response, { depth: null });

		// Write only the transcript to the console
		//console.dir(response.results.channels[0].alternatives[0].transcript, { depth: null });
	})
	.catch((err) => {
		console.log(err);
	});

// Example filename: Program.cs

using Deepgram.Clients;
using Deepgram.Models;
using Newtonsoft.Json;

namespace SampleApp
{
    class Program
    {
        const string API_KEY = "YOUR_DEEPGRAM_API_KEY";

        static async Task Main(string[] args)
        {   
            var credentials = new Credentials(API_KEY);
            var deepgramClient = new DeepgramClient(credentials);

            // UNCOMMENT IF USING LOCAL FILE:
            // using (FileStream fs = File.OpenRead("YOUR_FILE_LOCATION"))
            {
                var response = await deepgramClient.Transcription.Prerecorded.GetTranscriptionAsync(
                    // UNCOMMENT IF USING LOCAL FILE:
                    // new Deepgram.Transcription.StreamSource(
                    //     fs,
                    //     "audio/wav"),
                    new UrlSource("https://static.deepgram.com/examples/Bueller-Life-moves-pretty-fast.wav"),
                    new PrerecordedTranscriptionOptions()
                    {
                        Punctuate = true,
                        Utterances = true,
                    });

                Console.WriteLine(JsonConvert.SerializeObject(response));
            }
        }
    }
}

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"strings"

	"github.com/deepgram-devs/deepgram-go-sdk/deepgram"
)

func main() {
	credentials := "DEEPGRAM_API_KEY"
	dg := deepgram.NewClient(credentials)

	// Location of the file you want to transcribe. Should include filename and extension.
	// Example of a local file: ../../Audio/life-moves-pretty-fast.wav
	// Example of a remote file: https://static.deepgram.com/examples/interview_speech-analytics.wav
	FILE := "YOUR_FILE_LOCATION"
	var res interface{}
	var err error

	if isURL(FILE) {
		res, err = dg.PreRecordedFromURL(
			deepgram.UrlSource{Url: FILE},
			deepgram.PreRecordedTranscriptionOptions{
				Punctuate:  true,
				Diarize:    true,
				Language:   "en-US",
				Utterances: true,
			},
		)
		if err != nil {
			fmt.Println("ERROR", err)
			return
		}
	} else {
		file, err := os.Open(FILE)
		if err != nil {
			log.Panicf("error opening file %s: %v", FILE, err)
		}
		defer file.Close()

		source := deepgram.ReadStreamSource{Stream: file, Mimetype: "YOUR_FILE_MIME_TYPE"}

		res, err = dg.PreRecordedFromStream(
			source,
			deepgram.PreRecordedTranscriptionOptions{
				Punctuate:  true,
				Diarize:    true,
				Language:   "en-US",
				Utterances: true,
			},
		)
		if err != nil {
			fmt.Println("ERROR", err)
			return
		}
	}

	jsonStr, err := json.MarshalIndent(res, "", "  ")
	if err != nil {
		fmt.Println("Error marshaling JSON:", err)
		return
	}

	log.Printf("%s", jsonStr)
}

// Function to check if a string is a valid URL
func isURL(str string) bool {
	return strings.HasPrefix(str, "http://") || strings.HasPrefix(str, "https://")
}

# Run your application using the file you created in the previous step
# Example: python deepgram_test.py
python YOUR_PROJECT_NAME.py

# Run your application using the file you created in the previous step
# Example: node index.js
node YOUR_PROJECT_NAME.js

// Run your application 
dotnet run

go run YOUR_PROJECT_NAME.go 

{
  "metadata":{
    "transaction_key":"Ha0aVG...",
    "request_id":"se24UY...",
    "sha256":"2d5b81...",
    "created":"2021-07-08T09:11:38.593Z",
    "duration":19.0,
    "channels":1
  },
  "results":{
    "channels":[
      {
        "alternatives":[
          {
            "transcript":"Yep. I said it before, and I'll say it again. Life moves pretty fast. You don't stop and look around once in a while. You could miss it.t.
            "confidence":0.9757011,
            "words":[
              {
                "word":"yep",
                "start":5.66,
                "end":5.94,
                "confidence":0.994987,
                "punctuated_word":"Yep."
              },
              {
                "word":"i",
                "start":7.2344832,
                "end":7.434014,
                "confidence":0.8217165,
                "punctuated_word":"I"
              },
              {
                "word":"said",
                "start":7.434014,
                "end":7.5537324,
                "confidence":0.979774,
                "punctuated_word":"said"
              },
              ...
            ]
          }
        ]
      }
    ]
  }
}

    response = await asyncio.create_task(
      deepgram.transcription.prerecorded(
        source,
        {
          'punctuate': True,
          'language': 'es'
        }
      )
    )

deepgram.transcription.preRecorded(source, {
	punctuate: true,
	language: "es",
});

var response = await deepgram.Transcription.Prerecorded.GetTranscriptionAsync(
  new Deepgram.Transcription.UrlSource(source),
  new PrerecordedTranscriptionOptions()
  {
    Punctuate = true,
    Utterances = true,
  });

res, err := dg.PreRecordedFromURL(deepgram.UrlSource{Url: source},
   deepgram.PreRecordedTranscriptionOptions{Punctuate: true, Language: "es", Search: []string{"SEARCH_TERM"}})