⌘ K
curl → go · net/http · idiomatic · headers · body · live

Convert cURL to Go

Translate a cURL command into a Go net/http snippet. The output is idiomatic — explicit error checks, deferred close, structured headers.

cURL → Go (net/http)
Input
161 B
4 lines
Output
429 B
17 lines
Status
ready
live
Ratio
2.66×
out/in
input · curl command
output · go (net/http)
package main
import (
	"fmt"
	"io"
	"net/http"
	"strings"
)
func main() {
	body := strings.NewReader(`{"name":"Alice","role":"admin"}`)
	req, _ := http.NewRequest("POST", "https://api.example.com/users", body)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer abc123")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}
Quick Start

How to port cURL to Go (net/http)

Go's net/http exposes a request builder pattern. The generator constructs an http.NewRequest, populates headers, sets the body and calls http.DefaultClient.Do. Auth tokens come through as Authorization headers.

  1. 01

    Paste cURL

    From DevTools, Postman, an SDK doc — anything that emits a cURL command.

    Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.

    inputstricttolerantliveparse
    in · sourcecurl · live
    curl -X POST https://api.example.com
    loaded · parsedtarget · ready
  2. 02

    Parser pulls fields

    URL, method, headers, body and basic auth are extracted into a structured shape.

    Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.

    parsetype-preservinglosslesslivememoised
    url · optionsheaders · live
    { url, method, headers, data }
    options applied · liveround-trip
  3. 03

    Emit Go (net/http)

    The generator turns the parsed command into idiomatic code for the target stack.

    Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.

    genidempotentround-tripdiff-cleandeterministic
    out · convertedGo (net/http) · ready
    req, _ := http.NewRequest(method, url, body)
res, _ := http.DefaultClient.Do(req)
    converted · livediff-clean
  4. 04

    Copy or download

    Drop into your project and tweak as needed.

    Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.

    exportclipboardtarget MIMEblobclient-side
    ✓ · copiedready · done
    ✓ Copied
    shipped · ready to shipsuccess
Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Related toolscURL to fetch()cURL to CodecURL to PythoncURL to RustHAR to cURLcURL to Java
Use Cases

When to port cURL to Go (net/http)

Migration, polyglot teams, integration tests.

Backend services

Drop into a Go HTTP handler or worker. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

CLI tools

Build a quick cobra command from a curl example. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Microservices

Wire a downstream call into a Go service. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

Tests

Use as the basis for a httptest-based integration test. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

lossless

Migrations

Move a Python tool over to Go with the curl as the contract. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Polyglot hand-off

Hand a curl off to the Go team in their idiom. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade
FAQ

Frequently asked questions

Not yet — the snippet uses the default client. Switch to http.NewRequestWithContext if you need cancellation.
The snippet reads the body but doesn't JSON-decode it. Add json.NewDecoder(res.Body).Decode(&out) after pasting.
Default TLS config is used. Override the transport for custom certificates or pinning.
Basic --data only. Use mime/multipart manually for -F multipart payloads.
No. Parsing and code generation run locally in your browser.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!