Go HTTP Patterns

Use Go's standard library (net/http) to integrate with the FOTOhub API. There is no official Go SDK — these patterns show idiomatic, production-ready HTTP integration using only the standard library.

No SDK Required

Go's net/http package is powerful enough for direct API integration. The patterns below give you a reusable client with retries, streaming, async polling, file uploads, webhook verification, and rate limiting — all without third-party dependencies.

Reusable Client Struct

A production-ready HTTP client with base URL configuration, automatic retries with exponential backoff, and configurable timeouts. Use a single instance across your application — it is safe for concurrent use.

PythonTypeScriptGocURL

python

from fotohub import FotoHub

client = FotoHub(
    api_key="fh_live_your_api_key",
    max_retries=3,
    timeout=30.0
)

typescript

import { FotoHub } from "fotohub";

const client = new FotoHub({ 
    apiKey: "fh_live_your_api_key",
    maxRetries: 3,
    timeout: 30000
});

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

type FotoHubClient struct {
    APIKey     string
    BaseURL    string
    HTTPClient *http.Client
}

func NewFotoHubClient(apiKey string) *FotoHubClient {
    return &FotoHubClient{
        APIKey:  apiKey,
        BaseURL: "https://apis.fotohub.app/v1",
        HTTPClient: &http.Client{
            Timeout: 30 * time.Second,
        },
    }
}

func (c *FotoHubClient) Post(ctx context.Context, path string, body interface{}) ([]byte, error) {
    var reqBody io.Reader
    if body != nil {
        jsonBody, err := json.Marshal(body)
        if err != nil {
            return nil, err
        }
        reqBody = bytes.NewReader(jsonBody)
    }

    req, err := http.NewRequestWithContext(ctx, "POST", c.BaseURL+path, reqBody)
    if err != nil {
        return nil, err
    }

    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    respBody, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    if resp.StatusCode >= 400 {
        return nil, fmt.Errorf("API error: %s - %s", resp.Status, string(respBody))
    }

    return respBody, nil
}

bash

# Client configuration is not applicable to cURL

Image Generation

API endpoints and wrappers for Image Generation. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.images.generate(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.images.generate({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type GenerateImageRequest struct {
    Param string `json:"param"`
}

type GenerateImageResponse struct {
    URL string `json:"url"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func GenerateImage(ctx context.Context, client *FotoHubClient, req GenerateImageRequest) (*GenerateImageResponse, error) {
    respData, err := client.Post(ctx, "/ai/generate/image", req)
    if err != nil {
        return nil, err
    }
    
    var result GenerateImageResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/ai/generate/image \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Video Generation

API endpoints and wrappers for Video Generation. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.videos.generate(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.videos.generate({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type GenerateVideoRequest struct {
    Param string `json:"param"`
}

type GenerateVideoResponse struct {
    JobID string `json:"jobid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func GenerateVideo(ctx context.Context, client *FotoHubClient, req GenerateVideoRequest) (*GenerateVideoResponse, error) {
    respData, err := client.Post(ctx, "/ai/generate/video", req)
    if err != nil {
        return nil, err
    }
    
    var result GenerateVideoResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/ai/generate/video \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Audio & TTS

API endpoints and wrappers for Audio & TTS. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.audio.tts(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.audio.tts({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type GenerateAudioRequest struct {
    Param string `json:"param"`
}

type GenerateAudioResponse struct {
    URL string `json:"url"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func GenerateAudio(ctx context.Context, client *FotoHubClient, req GenerateAudioRequest) (*GenerateAudioResponse, error) {
    respData, err := client.Post(ctx, "/audio/tts", req)
    if err != nil {
        return nil, err
    }
    
    var result GenerateAudioResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/audio/tts \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Document Intelligence

API endpoints and wrappers for Document Intelligence. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.documents.analyze(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.documents.analyze({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type AnalyzeDocumentRequest struct {
    Param string `json:"param"`
}

type AnalyzeDocumentResponse struct {
    JobID string `json:"jobid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func AnalyzeDocument(ctx context.Context, client *FotoHubClient, req AnalyzeDocumentRequest) (*AnalyzeDocumentResponse, error) {
    respData, err := client.Post(ctx, "/documents/analyze", req)
    if err != nil {
        return nil, err
    }
    
    var result AnalyzeDocumentResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/documents/analyze \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Brand Engine

API endpoints and wrappers for Brand Engine. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.brands.create(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.brands.create({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type CreateBrandRequest struct {
    Param string `json:"param"`
}

type CreateBrandResponse struct {
    BrandID string `json:"brandid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func CreateBrand(ctx context.Context, client *FotoHubClient, req CreateBrandRequest) (*CreateBrandResponse, error) {
    respData, err := client.Post(ctx, "/brand/create", req)
    if err != nil {
        return nil, err
    }
    
    var result CreateBrandResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/brand/create \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

API endpoints and wrappers for Social Studio. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.social.schedule(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.social.schedule({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type SchedulePostRequest struct {
    Param string `json:"param"`
}

type SchedulePostResponse struct {
    PostID string `json:"postid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func SchedulePost(ctx context.Context, client *FotoHubClient, req SchedulePostRequest) (*SchedulePostResponse, error) {
    respData, err := client.Post(ctx, "/social/schedule", req)
    if err != nil {
        return nil, err
    }
    
    var result SchedulePostResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/social/schedule \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Virtual Try-On

API endpoints and wrappers for Virtual Try-On. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.tryon.submit(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.tryon.submit({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type SubmitTryonRequest struct {
    Param string `json:"param"`
}

type SubmitTryonResponse struct {
    JobID string `json:"jobid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func SubmitTryon(ctx context.Context, client *FotoHubClient, req SubmitTryonRequest) (*SubmitTryonResponse, error) {
    respData, err := client.Post(ctx, "/tryon/submit", req)
    if err != nil {
        return nil, err
    }
    
    var result SubmitTryonResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/tryon/submit \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Shorts & Clips

API endpoints and wrappers for Shorts & Clips. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.clips.submit(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.clips.submit({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type SubmitClippingRequest struct {
    Param string `json:"param"`
}

type SubmitClippingResponse struct {
    JobID string `json:"jobid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func SubmitClipping(ctx context.Context, client *FotoHubClient, req SubmitClippingRequest) (*SubmitClippingResponse, error) {
    respData, err := client.Post(ctx, "/shorts/clips", req)
    if err != nil {
        return nil, err
    }
    
    var result SubmitClippingResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/shorts/clips \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter