> ## Documentation Index
> Fetch the complete documentation index at: https://docs.moderationapi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Content moderation with Go

> Learn how to moderate content using Moderation API's REST endpoints with Go

***

<Snippet file="prerequisites.mdx" />

***

## 1. Install SDK

We currently don't have an official SDK for Go, but you can use the [OpenAPI Generator](https://docs.moderationapi.com/resources/generate-client-openapi) to generate a Go client or simply call the API directly using Go's standard `net/http` package.

## 2. Submit content

Grab the API key from your [project](https://dash.moderationapi.com) and begin submitting text, images, or other media to your project for moderation.

```go Text moderation theme={"theme":"nord"}
package main

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

func main() {
    // Configure the client
    apiKey := "your-api-key" // Replace with your API key
    baseURL := "https://api.moderationapi.com/v1"

    // Prepare request body
    requestBody, err := json.Marshal(map[string]interface{}{
        "content": map[string]interface{}{
            "type": "text",
            "text": "Hello world!",
        },
        "authorId":       "user-123",
        "conversationId": "room-456",
        "metadata": map[string]interface{}{
            "customField": "value",
        },
    })
    if err != nil {
        panic(err)
    }

    // Create request
    req, err := http.NewRequest("POST", baseURL+"/moderate", bytes.NewBuffer(requestBody))
    if err != nil {
        panic(err)
    }

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

    // Send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // Read response
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    // Parse response
    var textAnalysis map[string]interface{}
    if err := json.Unmarshal(body, &textAnalysis); err != nil {
        panic(err)
    }

    evaluation := textAnalysis["evaluation"].(map[string]interface{})
    if evaluation["flagged"].(bool) {
        fmt.Println("Text content flagged")
        // Block the content, show an error, etc...
    } else {
        fmt.Println("Text content is safe.")
        // Save to database or proceed...
    }
}
```

```go Image moderation theme={"theme":"nord"}
package main

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

func main() {
    // Configure the client
    apiKey := "your-api-key" // Replace with your API key
    baseURL := "https://api.moderationapi.com/v1"

    // Prepare request body
    requestBody, err := json.Marshal(map[string]interface{}{
        "content": map[string]interface{}{
            "type": "image",
            "url":  "https://example.com/image.jpg",
        },
        "authorId": "user-123",
        "metadata": map[string]interface{}{
            "customField": "value",
        },
    })
    if err != nil {
        panic(err)
    }

    // Create request
    req, err := http.NewRequest("POST", baseURL+"/moderate", bytes.NewBuffer(requestBody))
    if err != nil {
        panic(err)
    }

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

    // Send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // Read response
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    // Parse response
    var imageAnalysis map[string]interface{}
    if err := json.Unmarshal(body, &imageAnalysis); err != nil {
        panic(err)
    }

    evaluation := imageAnalysis["evaluation"].(map[string]interface{})
    if evaluation["flagged"].(bool) {
        fmt.Println("Image content flagged")
        // Block or require review
    } else {
        fmt.Println("Image is safe.")
        // Save to database or proceed...
    }
}
```

```go Object moderation theme={"theme":"nord"}
package main

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

func main() {
    // Configure the client
    apiKey := "your-api-key" // Replace with your API key
    baseURL := "https://api.moderationapi.com/v1"

    // Prepare request body
    requestBody, err := json.Marshal(map[string]interface{}{
        "content": map[string]interface{}{
            "type": "object",
            "data": map[string]interface{}{
                "name": map[string]interface{}{
                    "type": "text",
                    "text": "John Doe",
                },
                "email": map[string]interface{}{
                    "type": "text",
                    "text": "john.doe@example.com",
                },
                "picture": map[string]interface{}{
                    "type": "image",
                    "url":  "https://example.com/image.jpg",
                },
            },
        },
        "authorId": "user-123",
        "metadata": map[string]interface{}{
            "customField": "value",
        },
    })
    if err != nil {
        panic(err)
    }

    // Create request
    req, err := http.NewRequest("POST", baseURL+"/moderate", bytes.NewBuffer(requestBody))
    if err != nil {
        panic(err)
    }

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

    // Send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // Read response
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    // Parse response
    var objectAnalysis map[string]interface{}
    if err := json.Unmarshal(body, &objectAnalysis); err != nil {
        panic(err)
    }

    evaluation := objectAnalysis["evaluation"].(map[string]interface{})
    if evaluation["flagged"].(bool) {
        fmt.Println("Object content flagged")
        // Block or require review
    } else {
        fmt.Println("Object is safe.")
        // Save to database or proceed...
    }
}
```

***

<Snippet file="dry-run.mdx" />

***

<Snippet file="review-flagged.mdx" />

***

<Snippet file="all-done.mdx" />