Go SDK

go get github.com/ujeebu/ujeebu-go

package main

import (
    "fmt"
    "log"
    "github.com/ujeebu/ujeebu-go"
)

func main() {
    // Initialize with your API key
    client, err := ujeebu.NewClient("your-api-key")
    if err != nil {
        log.Fatal(err)
    }

    // Scrape a website
    result, credits, err := client.Scrape(ujeebu.ScrapeParams{
        URL: "https://example.com",
        JS:  true,
        ResponseType: "html",
    })

    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Credits used: %d\n", credits)
    fmt.Println(result)
}

package main

import (
    "os"
    "log"
    "github.com/ujeebu/ujeebu-go"
)

func main() {
    client, err := ujeebu.NewClient(os.Getenv("UJEEBU_API_KEY"))
    if err != nil {
        log.Fatal(err)
    }
    // Use client...
}

result, credits, err := client.Scrape(ujeebu.ScrapeParams{
    URL: "https://example.com",
})
if err != nil {
    log.Fatal(err)
}
fmt.Println(result)

article, credits, err := client.Extract(ujeebu.ExtractParams{
    URL: "https://example.com/article",
})

if err != nil {
    log.Fatal(err)
}

fmt.Println(article.Title)
fmt.Println(article.Author)
fmt.Println(article.Text)
fmt.Println(article.PubDate)

results, credits, err := client.GoogleSearch(ujeebu.SerpParams{
    Search:       "artificial intelligence",
    Lang:         "en",
    ResultsCount: 20,
})

if err != nil {
    log.Fatal(err)
}

fmt.Printf("Credits used: %d\n", credits)
for _, result := range results.OrganicResults {
    fmt.Println(result.Title)
    fmt.Println(result.Link)
}

card, credits, err := client.Preview(ujeebu.PreviewParams{
    URL: "https://example.com/article",
})

if err != nil {
    log.Fatal(err)
}

fmt.Println(card.Title)
fmt.Println(card.Description)
fmt.Println(card.Image)

result, credits, err := client.AIScrape(ujeebu.AIScrapeParams{
    URL:    "https://example.com/product",
    Prompt: "Extract the product name, price, and rating",
})

if err != nil {
    log.Fatal(err)
}

fmt.Println(result.Data)

result, credits, err := client.AutoExtract(ujeebu.AutoExtractParams{
    URL: "https://example.com/article",
})

if err != nil {
    log.Fatal(err)
}

fmt.Printf("Page type: %s\n", result.PageType)
fmt.Println(result.Data)

result, credits, err := client.Markdown(ujeebu.MarkdownParams{
    URL: "https://example.com/article",
})

if err != nil {
    log.Fatal(err)
}

fmt.Println(result.Markdown)

pdfBytes, _, err := client.GetPDF(ujeebu.ScrapeParams{
    URL:     "https://example.com",
    JS:      true,
    WaitFor: "2000",
})

if err != nil {
    log.Fatal(err)
}

err = os.WriteFile("page.pdf", pdfBytes, 0644)
if err != nil {
    log.Fatal(err)
}

imgBytes, _, err := client.GetScreenshot(ujeebu.ScrapeParams{
    URL:                "https://example.com",
    JS:                 true,
    ScreenshotFullpage: true,
})

if err != nil {
    log.Fatal(err)
}

err = os.WriteFile("screenshot.png", imgBytes, 0644)

result, credits, err := client.Scrape(ujeebu.ScrapeParams{
    URL: "https://example.com",
})

if err != nil {
    switch e := err.(type) {
    case *ujeebu.APIError:
        fmt.Printf("API Error: %d - %s\n", e.StatusCode, e.Message)
    case *ujeebu.NetworkError:
        fmt.Printf("Network Error: %s\n", e.Error())
    case *ujeebu.TimeoutError:
        fmt.Println("Request timed out")
    default:
        fmt.Printf("Unknown error: %s\n", err.Error())
    }
    return
}

fmt.Println(result)

package main

import (
    "fmt"
    "sync"
    "github.com/ujeebu/ujeebu-go"
)

func main() {
    client, _ := ujeebu.NewClient(os.Getenv("UJEEBU_API_KEY"))
    
    urls := []string{
        "https://example1.com",
        "https://example2.com",
        "https://example3.com",
    }
    
    var wg sync.WaitGroup
    results := make(chan string, len(urls))
    
    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()
            result, _, err := client.Scrape(ujeebu.ScrapeParams{URL: url})
            if err != nil {
                results <- fmt.Sprintf("Error: %s", err)
                return
            }
            results <- fmt.Sprintf("Got %d bytes from %s", len(result), url)
        }(url)
    }
    
    wg.Wait()
    close(results)
    
    for result := range results {
        fmt.Println(result)
    }
}

package main

import (
    "context"
    "time"
    "github.com/ujeebu/ujeebu-go"
)

func main() {
    client, _ := ujeebu.NewClient(os.Getenv("UJEEBU_API_KEY"))
    
    // Create context with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    result, _, err := client.ScrapeWithContext(ctx, ujeebu.ScrapeParams{
        URL: "https://example.com",
        JS:  true,
    })
    
    if err != nil {
        if ctx.Err() == context.DeadlineExceeded {
            fmt.Println("Request timed out")
        } else {
            fmt.Printf("Error: %s\n", err)
        }
        return
    }
    
    fmt.Println(result)
}