#Errors

{
  "code": "invalid_argument",
  "message": "Request validation failed",
  "details": [
    {
      "type": "transcodely.v1.ErrorDetails",
      "value": {
        "code": "validation_error",
        "message": "Request validation failed",
        "field_violations": [
          {
            "field": "outputs[0].video[0].codec",
            "description": "codec is required"
          },
          {
            "field": "input_url",
            "description": "must match pattern: ^(gs|s3|https?)://.*$"
          }
        ]
      }
    }
  ]
}

{
  "code": "unauthenticated",
  "message": "Invalid or missing API key"
}

{
  "code": "not_found",
  "message": "Job not found: job_nonexistent123"
}

{
  "code": "invalid_argument",
  "message": "Request validation failed",
  "details": [
    {
      "type": "transcodely.v1.ErrorDetails",
      "value": {
        "code": "validation_error",
        "message": "Request validation failed",
        "field_violations": [
          {
            "field": "outputs[0].video[0].h264.crf",
            "description": "CRF must be between 15 and 35"
          }
        ]
      }
    }
  ]
}

{
  "code": "permission_denied",
  "message": "Organization is suspended"
}

{
  "code": "already_exists",
  "message": "Preset with slug 'web_720p_fast' already exists"
}

{
  "code": "failed_precondition",
  "message": "Job is not in a cancelable state: completed"
}

# Capture the response body and the HTTP status separately (no -f, so the
# error body is still written to /tmp/resp.json on a 4xx/5xx).
http_status=$(curl -sS -o /tmp/resp.json -w '%{http_code}' 
  -X POST "https://api.transcodely.com/transcodely.v1.JobService/Create" 
  -H "Authorization: Bearer {{API_KEY}}" 
  -H "Content-Type: application/json" 
  -d '{"input_url": "not-a-url", "outputs": []}')

if [ "$http_status" -ge 400 ]; then
  # Top-level Connect code (e.g. "invalid_argument", "not_found").
  jq -r '.code, .message' /tmp/resp.json
  # Field-level violations, when present (HTTP 400/422).
  jq -r '.details[]?.value.field_violations[]? | "(.field): (.description)"' /tmp/resp.json
fi

import {
  TranscodelyError,
  AuthenticationError,
  NotFoundError,
  RateLimitError,
  InvalidRequestError,
} from "transcodely";

try {
  await client.jobs.create(request);
} catch (err) {
  if (err instanceof InvalidRequestError) {
    for (const v of err.errors) {
      console.error(`${v.field}: ${v.description}`);
    }
  } else if (err instanceof RateLimitError) {
    await new Promise((r) => setTimeout(r, err.retryAfterMs ?? 1000));
  } else if (err instanceof NotFoundError) {
    console.error("not found:", err.message);
  } else if (err instanceof AuthenticationError) {
    console.error("bad API key");
  } else if (err instanceof TranscodelyError) {
    console.error(`[${err.requestId}] ${err.code}: ${err.message}`);
  } else {
    throw err;
  }
}

import time
from transcodely import (
    TranscodelyError,
    AuthenticationError,
    NotFoundError,
    RateLimitError,
    InvalidRequestError,
)

try:
    client.jobs.create(input_url=..., outputs=[...])
except InvalidRequestError as err:
    for v in err.errors:
        print(f"{v.field}: {v.description}")
except RateLimitError as err:
    time.sleep((err.retry_after_ms or 1000) / 1000)
except NotFoundError as err:
    print(f"not found: {err}")
except AuthenticationError:
    print("bad API key")
except TranscodelyError as err:
    print(f"[{err.request_id}] {err.code}: {err}")

import (
    "errors"
    "time"

    "github.com/transcodely/transcodely-go"
)

job, err := client.Jobs.Create(ctx, params)
if err != nil {
    var notFound *transcodely.NotFoundError
    var invalid  *transcodely.InvalidRequestError
    var rate     *transcodely.RateLimitError
    var auth     *transcodely.AuthenticationError

    switch {
    case errors.As(err, &notFound):
        log.Printf("not found, request_id=%s", notFound.RequestID())
    case errors.As(err, &invalid):
        for _, v := range invalid.Errors() {
            log.Printf("%s: %s", v.Field, v.Description)
        }
    case errors.As(err, &rate):
        time.Sleep(rate.RetryAfter)
    case errors.As(err, &auth):
        log.Fatal("bad API key")
    default:
        log.Fatal(err)
    }
}
_ = job

import { ConnectError, Code } from '@connectrpc/connect';

try {
  const job = await client.create(request);
} catch (err) {
  if (err instanceof ConnectError) {
    switch (err.code) {
      case Code.InvalidArgument:
        // Parse field violations from err.details
        console.error('Validation failed:', err.message);
        break;
      case Code.NotFound:
        console.error('Resource not found');
        break;
      case Code.Unauthenticated:
        // Redirect to login or refresh credentials
        break;
      case Code.Unavailable:
        // Retry with exponential backoff
        break;
      default:
        console.error('Unexpected error:', err.code, err.message);
    }
  }
}

# Python has no low-level Connect client — use the SDK's typed errors instead.
from transcodely import (
    InvalidRequestError,
    NotFoundError,
    AuthenticationError,
    APIError,
    TranscodelyError,
)

try:
    job = client.jobs.create(input_url=..., outputs=[...])
except InvalidRequestError as err:
    # Field violations are already parsed for you.
    for v in err.errors:
        print(f"validation failed: {v.field}: {v.description}")
except NotFoundError:
    print("resource not found")
except AuthenticationError:
    # Refresh credentials.
    ...
except APIError:
    # 5xx / unavailable — retry with exponential backoff.
    ...
except TranscodelyError as err:
    print(f"unexpected error: {err.code}: {err}")

import (
	"errors"

	"connectrpc.com/connect"
)

// client is a generated connect-go stub, e.g. from
// transcodelyv1connect.NewJobServiceClient(httpClient, "https://api.transcodely.com").
_, err := client.Create(ctx, connect.NewRequest(req))
if err != nil {
	var connectErr *connect.Error
	if errors.As(err, &connectErr) {
		switch connectErr.Code() {
		case connect.CodeInvalidArgument:
			// Field violations live in connectErr.Details().
			log.Printf("validation failed: %v", connectErr.Message())
		case connect.CodeNotFound:
			log.Print("resource not found")
		case connect.CodeUnauthenticated:
			// Refresh credentials.
		case connect.CodeUnavailable:
			// Retry with exponential backoff.
		default:
			log.Printf("unexpected error: %v: %v", connectErr.Code(), connectErr.Message())
		}
	}
}