---
title: "Forwarding Emails"
canonical: "https://test.abhinandan.one/go-forwarding-emails"
markdown_url: "https://test.abhinandan.one/go-forwarding-emails.md"
publisher: "Primitive SDKs"
kind: "guide"
content_type: "reference"
category: "Go SDK"
description: "Client.Forward in the Go SDK sends an inbound ReceivedEmail to a new recipient as a fresh outbound message with a generated forwarded-message body."
keywords: ["Client.Forward", "ForwardParams", "forward an inbound email Go", "sdk-go forward", "buildForwardText"]
last_modified: "2026-08-11T18:54:53.27421+00:00"
published_at: "2026-08-11T18:54:53.125197+00:00"
source_files:
  - "sdk-go/client.go"
  - "sdk-go/README.md"
sections:
  - {anchor: "what-you-need-before-forwarding", title: "What you need before forwarding"}
  - {anchor: "forward-an-inbound-email", title: "Forward an inbound email"}
  - {anchor: "step-call-clientforward-with-the-inbound-email-and-a-recipient", title: "Call Client.Forward with the inbound email and a recipient"}
  - {anchor: "step-read-the-generated-forwarded-message-body", title: "Read the generated forwarded-message body"}
  - {anchor: "step-verify-delivery", title: "Verify delivery"}
  - {anchor: "forwardparams-fields", title: "ForwardParams fields"}
  - {anchor: "next-steps", title: "Next steps"}
---

> Documentation index: https://test.abhinandan.one/llms.txt

# Forwarding Emails

Forward a received email to a new recipient with the Go SDK's Client.Forward, which builds a "Forwarded message" body from the original email and sends it as a new outbound message.

Use `Client.Forward` when you want to hand an inbound email off to someone who wasn't on the original thread, rather than replying to the sender. Reach for this instead of [Client.Reply](https://test.abhinandan.one/go-replying-to-emails.md) whenever the new recipient needs the original message content but isn't part of the existing conversation.

Under the hood, `Forward` is not a distinct API operation: it builds a `SendParams` value from the `ReceivedEmail` and calls `Client.Send`, so a forward is really a synthesized outbound send. See [Sending Emails](https://test.abhinandan.one/go-sending-emails.md) for the underlying delivery semantics (wait mode, idempotency).

## What you need before forwarding

- A `*primitive.Client` constructed with [`primitive.NewClient`](https://test.abhinandan.one/go-client-configuration.md).
- A `*primitive.ReceivedEmail` from [`primitive.Receive`](https://test.abhinandan.one/go-receiving-webhooks.md) or `ReceiveFromHTTPRequest`.
- The recipient address for the forward.

## Forward an inbound email

### 1. Call Client.Forward with the inbound email and a recipient

Pass the `*ReceivedEmail` you received and a `ForwardParams` with at least `To`:

```go
package main

import (
	"context"
	"log"

	primitive "github.com/primitivedotdev/sdks/sdk-go"
)

func handleForward(ctx context.Context, client *primitive.Client, email *primitive.ReceivedEmail) {
	result, err := client.Forward(ctx, email, primitive.ForwardParams{
		To:       "ops@example.com",
		BodyText: "Can you take this one?",
	})
	if err != nil {
		log.Printf("forward failed: %v", err)
		return
	}
	log.Println(result.ID, result.Status)
}
```

### 2. Read the generated forwarded-message body

`Forward` prepends your `BodyText` (when set) to a generated block, then appends the original email's headers and text body:

```text
Can you take this one?

---------- Forwarded message ----------
From: Alice <alice@example.com>
To: support@example.com
Subject: Order question
Date: Tue, 14 Dec 2025 11:59:50 +0000
Message-ID: <abc123@example.com>

<original email text>
```

The `Date` line only appears when the inbound email's headers included one; `Message-ID` only appears when the inbound thread had one.

### 3. Verify delivery

`Forward` returns the same `SendResult` shape as `Send`: check `result.Status` and, when you cared enough to opt into [wait mode](https://test.abhinandan.one/email-model.md), `result.DeliveryStatus`. Forward has no `Wait` option of its own, see the note below.

## ForwardParams fields

| Field | Required | Behavior |
| --- | --- | --- |
| `To` | yes | Recipient of the forwarded message. Validated as an email address. |
| `BodyText` | no | Your own note, prepended above the generated forwarded block. |
| `Subject` | no | Overrides the subject. Defaults to `email.ForwardSubject` (`Fwd: <original subject>`, idempotently prefixed). |
| `From` | no | Overrides the From address. Defaults to `email.ReceivedBy` (the address that received the inbound email). |
| `IdempotencyKey` | no | Deduplicates retries the same way [`Client.Send`](https://test.abhinandan.one/go-sending-emails.md) does. |

> **Tip:** Forward routes through `Client.Send` internally, so the same [request validation rules](https://test.abhinandan.one/go-sending-emails.md) apply: `To` must be a syntactically valid address, and the SDK rejects a call before it reaches the network if not.

> **Warning:** `ForwardParams` has no `Wait` field. If you need the first downstream SMTP delivery outcome for the forwarded message before your handler returns, call `Client.Send` directly with `Wait` set instead of `Client.Forward`.