Skip to main content

Development Tools

Accelerate your integration with our development tools and resources. We provide various options to make working with the TranscriMed API easier.

Important: About SDKs​

Note: TranscriMed does not provide official SDKs. Our REST API is designed to be simple and compatible with any programming language using standard HTTP libraries. The resources below help you integrate quickly without the need for specific SDKs.

Available Tools​

🔧 Postman Collection​

Run the TranscriMed API from Postman or newman.

What it contains​

  • Integration key (B2B) folder: the whole integration-key flow in order, runnable end to end with the Collection Runner or newman. It exchanges and refreshes the key, lists templates, generates a document (async, then sync), polls the job, looks it up by external_reference_id, corrects the document by text and reads it back. Optional: correct by voice.
  • Scripts that store the tokens and ids, set a fresh Idempotency-Key for each submission, and poll a job until it finishes (bounded, about 6 minutes by default).
  • Integration key (B2B): error examples: credential-free requests showing the error shapes.
  • OAuth2 folders for partner apps acting for a TranscriMed user. The Jobs API (legacy) folder targets the deprecated /api/v1/jobs endpoints.
  • Example responses for the main B2B steps.

How to Use​

  1. Download the collection, transcrimed-api.postman_collection.json, and an environment:

    • Sandbox (https://api.sandbox.transcrimed.com.br): integrate and test here, with a sandbox key.
    • Production (https://api.transcrimed.com.br): real use.

  2. Import both into Postman and select the environment.

  3. Set your credential as the environment's current value: integration_key (company accounts), or client_id / client_secret (OAuth2 partner apps). The files ship with these empty; never commit them.

  4. Run the Integration key (B2B) folder with the Collection Runner, or:

    npx newman run transcrimed-api.postman_collection.json \
      -e Sandbox.postman_environment.json \
      --env-var integration_key="$TRANSCRIMED_INTEGRATION_KEY" \
      --folder "Integration key (B2B)"

Each run generates two documents, which consume credits of the account, from a short invented note. Use only fictitious data in the sandbox. Details are in the collection README.

📝 OpenAPI/Swagger Specifications​

Generate client code automatically or explore the API interactively.

Available Files​

Generating Client Code​

Use tools like OpenAPI Generator to generate clients in any language:

# Example: Generate Python client
openapi-generator generate \
  -i https://developers.transcrimed.com.br/api-specs/medical-records-api.yaml \
  -g python \
  -o ./transcrimed-client-python

# Example: Generate JavaScript client
openapi-generator generate \
  -i https://developers.transcrimed.com.br/api-specs/medical-records-api.yaml \
  -g javascript \
  -o ./transcrimed-client-js

# Example: Generate PHP client
openapi-generator generate \
  -i https://developers.transcrimed.com.br/api-specs/medical-records-api.yaml \
  -g php \
  -o ./transcrimed-client-php

🧪 Inline API Tester​

Test endpoints directly from the documentation pages using the embedded tester:

  • On the API Testing Guide, each example has a "Test this endpoint" panel.
  • Choose the environment (Local/Production), paste your Bearer token, and send the request.
  • Results are shown inline, with status and response body.

Tip: Prefer the embedded tester for a seamless workflow next to the docs.

📚 Code Examples​

Reference implementations in various programming languages.

JavaScript/Node.js​

// Example using native fetch
async function generateMedicalRecord(audioBase64, accessToken) {
  const response = await fetch('https://api.transcrimed.com.br/api/v1/medical-records/generate', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      audio: audioBase64,
      template_id: 'general-consultation',
      language: 'en',
      mode: 'async'
    })
  });
  
  return response.json();
}

// Example using axios
const axios = require('axios');

async function checkJobStatus(jobId, accessToken) {
  const response = await axios.get(
    `https://api.transcrimed.com.br/api/v1/pipeline/jobs/${jobId}`,
    {
      headers: {
        'Authorization': `Bearer ${accessToken}`
      }
    }
  );
  
  return response.data;
}

Python​

import requests
import base64

# Example using requests
def generate_medical_record(audio_path, access_token):
    # Read and encode audio
    with open(audio_path, 'rb') as f:
        audio_base64 = base64.b64encode(f.read()).decode('utf-8')
    
    # Make request
    response = requests.post(
        'https://api.transcrimed.com.br/api/v1/medical-records/generate',
        headers={
            'Authorization': f'Bearer {access_token}',
            'Content-Type': 'application/json'
        },
        json={
            'audio': audio_base64,
            'template_id': 'general-consultation',
            'language': 'en',
            'mode': 'async'
        }
    )
    
    return response.json()

# Example using httpx (async)
import httpx
import asyncio

async def check_job_status(job_id, access_token):
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f'https://api.transcrimed.com.br/api/v1/pipeline/jobs/{job_id}',
            headers={'Authorization': f'Bearer {access_token}'}
        )
        return response.json()

PHP​

<?php
// Example using cURL
function generateMedicalRecord($audioPath, $accessToken) {
    // Read and encode audio
    $audioContent = file_get_contents($audioPath);
    $audioBase64 = base64_encode($audioContent);
    
    // Prepare data
    $data = [
        'audio' => $audioBase64,
        'template_id' => 'general-consultation',
        'language' => 'en',
        'mode' => 'async'
    ];
    
    // Configure cURL
    $ch = curl_init('https://api.transcrimed.com.br/api/v1/medical-records/generate');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: Bearer ' . $accessToken,
        'Content-Type: application/json'
    ]);
    
    // Execute and return
    $response = curl_exec($ch);
    curl_close($ch);
    
    return json_decode($response, true);
}

// Example using Guzzle
use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://api.transcrimed.com.br']);

$response = $client->post('/api/v1/medical-records/generate', [
    'headers' => [
        'Authorization' => 'Bearer ' . $accessToken,
        'Content-Type' => 'application/json'
    ],
    'json' => [
        'audio' => $audioBase64,
        'template_id' => 'general-consultation',
        'language' => 'en',
        'mode' => 'async'
    ]
]);

$result = json_decode($response->getBody(), true);

Go​

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "io/ioutil"
    "net/http"
)

type GenerateRequest struct {
    Audio      string `json:"audio"`
    TemplateID string `json:"template_id"`
    Language   string `json:"language"`
    Mode       string `json:"mode"`
}

func generateMedicalRecord(audioPath string, accessToken string) (map[string]interface{}, error) {
    // Read and encode audio
    audioData, err := ioutil.ReadFile(audioPath)
    if err != nil {
        return nil, err
    }
    audioBase64 := base64.StdEncoding.EncodeToString(audioData)
    
    // Prepare request
    reqData := GenerateRequest{
        Audio:      audioBase64,
        TemplateID: "general-consultation",
        Language:   "en",
        Mode:       "async",
    }
    
    jsonData, _ := json.Marshal(reqData)
    
    // Create HTTP request
    req, _ := http.NewRequest(
        "POST",
        "https://api.transcrimed.com.br/api/v1/medical-records/generate",
        bytes.NewBuffer(jsonData),
    )
    
    req.Header.Set("Authorization", "Bearer "+accessToken)
    req.Header.Set("Content-Type", "application/json")
    
    // Execute request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    // Read response
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    
    return result, nil
}

📊 Monitoring Dashboard​

Track API usage and real-time metrics.

Features​

  • API usage statistics
  • Request logs
  • Error analysis
  • Performance metrics
  • Billing reports

Access​

Open Dashboard

Since we don't provide official SDKs, we recommend using well-established HTTP libraries:

JavaScript/Node.js​

  • Axios - Promise-based HTTP client
  • Fetch API - Native browser API
  • Got - Human-friendly HTTP client

Python​

  • Requests - Simple and elegant HTTP library
  • httpx - HTTP client with async support
  • aiohttp - Asynchronous HTTP client/server

PHP​

  • Guzzle - Extensible PHP HTTP client
  • cURL - Native PHP extension

Java​

Go​

C#/.NET​

Ruby​

Developer Support​

Documentation​

Community​

Direct Support​

Next Steps​

  1. Explore the API with our Postman Collection
  2. Test endpoints in the API Playground
  3. Implement authentication following our OAuth2 Guide
  4. Configure webhooks for real-time notifications
  5. Monitor usage through the Dashboard

Need help? Contact our developer support team at developers@transcrimed.com.br