Chromedp

Using SurfSky with Chromedp

Prerequisites

To use SurfSky, you'll need the following:

1. API Key - A unique authentication token for accessing our services
2. Assigned Hostname - Your dedicated Surfsky endpoint
3. Proxies - Proxies in the format:

   protocol://username:password@host:port
   Supported protocols: HTTP, HTTPS, SOCKS5, SSH

To obtain your API key and hostname, please contact our team.

If you need proxies, please contact our team.

Code Example

First, install the required packages:

go get -u github.com/chromedp/chromedp

Here's a basic example of how to use SurfSky with Chromedp:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "bytes"
    "net/http"
    "io"
    "time"
    "github.com/chromedp/chromedp"
)

type Profile struct {
    WsURL string `json:"ws_url"`
}

func createProfile(apiToken string, proxy *string) (*Profile, error) {
    apiURL := "https://api-public.surfsky.io/profiles/one_time"
    
    data := make(map[string]interface{})
    if proxy != nil {
        data["proxy"] = *proxy
    }
    
    jsonData, err := json.Marshal(data)
    if err != nil {
        return nil, err
    }
    
    req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-Cloud-Api-Token", apiToken)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    bodyBytes, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API request failed with status: %d, body: %s", resp.StatusCode, string(bodyBytes))
    }
    
    var profile Profile
    if err := json.Unmarshal(bodyBytes, &profile); err != nil {
        return nil, fmt.Errorf("failed to parse JSON response: %v, body: %s", err, string(bodyBytes))
    }
        
    return &profile, nil
}

func main() {
    // Your credentials
    apiToken := "YOUR_API_TOKEN"
    proxy := "protocol://username:password@host:port"
    
    ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
    defer cancel()

    response, err := createProfile(apiToken, &proxy)
    if err != nil {
        log.Fatal(err)
    }

    allocatorCtx, cancel := chromedp.NewRemoteAllocator(ctx, response.WsURL, chromedp.NoModifyURL)
    defer cancel()

    taskCtx, cancel := chromedp.NewContext(allocatorCtx)
    defer cancel()

    var title string
    err = chromedp.Run(taskCtx,
        chromedp.Navigate("https://example.com"),
        chromedp.Title(&title),
    )
    if err != nil {
        log.Fatalf("Failed getting page title: %v", err)
    }

    log.Printf("Page title: %s", title)
}

Important Notes

• Always remember to close the browser when you're done to release your session limit. Inactive sessions are automatically closed after 30 seconds. Set inactive_kill_timeout to change this value.
• One time profile is used only once and then deleted. Use persistent profiles for long-term sessions
• A proxy is required and must be passed to the create_profile function
• You can run multiple sessions according to your subscription plan's session limit

For more advanced usage and error handling, check out our API Reference.