diff --git a/loadbalance_content_rewriting.go b/loadbalance_content_rewriting.go
new file mode 100644
index 0000000..21c094c
--- /dev/null
+++ b/loadbalance_content_rewriting.go
@@ -0,0 +1,221 @@
+package gofortiadc
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+)
+
+// LoadbalanceContentRewriting represents a content Rewriting request/response
+type LoadbalanceContentRewriting struct {
+	ActionType     string `json:"action_type"`
+	URLStatus      string `json:"url_status"`
+	URLContent     string `json:"url_content"`
+	RefererStatus  string `json:"referer_status"`
+	RefererContent string `json:"referer_content"`
+	Redirect       string `json:"redirect"`
+	Location       string `json:"location"`
+	HeaderName     string `json:"header_name"`
+	Comments       string `json:"comments"`
+	Mkey           string `json:"mkey"`
+	Action         string `json:"action"`
+	HostStatus     string `json:"host_status"`
+	HostContent    string `json:"host_content"`
+}
+
+// LoadbalanceGetContentRewritings returns the list of all content rewritings
+func (c *Client) LoadbalanceGetContentRewritings() ([]LoadbalanceContentRewriting, error) {
+	req, err := c.NewRequest("GET", fmt.Sprintf("%s/api/load_balance_content_rewriting", c.Address), nil)
+	if err != nil {
+		return []LoadbalanceContentRewriting{}, err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return []LoadbalanceContentRewriting{}, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return []LoadbalanceContentRewriting{}, fmt.Errorf("failed to get content rewriting list with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return []LoadbalanceContentRewriting{}, err
+	}
+
+	var LoadbalanceContentRewritingPayload struct {
+		Payload []LoadbalanceContentRewriting
+	}
+	err = json.Unmarshal(body, &LoadbalanceContentRewritingPayload)
+	if err != nil {
+		return []LoadbalanceContentRewriting{}, err
+	}
+
+	return LoadbalanceContentRewritingPayload.Payload, nil
+}
+
+// LoadbalanceGetContentRewriting returns a content rewriting by name
+func (c *Client) LoadbalanceGetContentRewriting(name string) (LoadbalanceContentRewriting, error) {
+	req, err := c.NewRequest("GET", fmt.Sprintf("%s/api/load_balance_content_rewriting", c.Address), nil)
+	if err != nil {
+		return LoadbalanceContentRewriting{}, err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return LoadbalanceContentRewriting{}, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return LoadbalanceContentRewriting{}, fmt.Errorf("failed to get content rewriting list with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return LoadbalanceContentRewriting{}, err
+	}
+
+	var LoadbalanceContentRewritingPayload struct {
+		Payload []LoadbalanceContentRewriting
+	}
+	err = json.Unmarshal(body, &LoadbalanceContentRewritingPayload)
+	if err != nil {
+		return LoadbalanceContentRewriting{}, err
+	}
+
+	for _, rs := range LoadbalanceContentRewritingPayload.Payload {
+		if rs.Mkey == name {
+			return rs, nil
+		}
+	}
+
+	return LoadbalanceContentRewriting{}, fmt.Errorf("content rewriting %s not found", name)
+}
+
+// LoadbalanceCreateContentRewriting creates a new content rewriting
+func (c *Client) LoadbalanceCreateContentRewriting(cr LoadbalanceContentRewriting) error {
+
+	payloadJSON, err := json.Marshal(cr)
+	if err != nil {
+		return err
+	}
+
+	req, err := c.NewRequest("POST", fmt.Sprintf("%s/api/load_balance_content_rewriting", c.Address), bytes.NewReader(payloadJSON))
+	if err != nil {
+		return err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return fmt.Errorf("content rewriting creation failed with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+
+	resJSON := struct{ Payload int }{}
+	err = json.Unmarshal(body, &resJSON)
+	if err != nil {
+		return err
+	}
+
+	if resJSON.Payload != 0 {
+		return fmt.Errorf("content rewriting creation failed: %s ", getErrorMessage(resJSON.Payload))
+	}
+
+	return nil
+}
+
+// LoadbalanceUpdateContentRewriting updates an existing content rewriting
+func (c *Client) LoadbalanceUpdateContentRewriting(cr LoadbalanceContentRewriting) error {
+
+	payloadJSON, err := json.Marshal(cr)
+	if err != nil {
+		return err
+	}
+
+	req, err := c.NewRequest("PUT", fmt.Sprintf("%s/api/load_balance_content_rewriting?mkey=%s", c.Address, cr.Mkey), bytes.NewReader(payloadJSON))
+	if err != nil {
+		return err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return fmt.Errorf("content rewriting update failed with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(body))
+
+	resJSON := struct{ Payload int }{}
+	err = json.Unmarshal(body, &resJSON)
+	if err != nil {
+		return err
+	}
+
+	if resJSON.Payload != 0 {
+		return fmt.Errorf("content rewriting update failed: %s", getErrorMessage(resJSON.Payload))
+	}
+
+	return nil
+}
+
+// LoadbalanceDeleteContentRewriting deletes an existing content rewriting
+func (c *Client) LoadbalanceDeleteContentRewriting(name string) error {
+
+	if len(name) == 0 {
+		return errors.New("content rewriting name cannot be empty")
+	}
+
+	req, err := c.NewRequest("DELETE", fmt.Sprintf("%s/api/load_balance_content_rewriting?mkey=%s", c.Address, name), nil)
+	if err != nil {
+		return err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return fmt.Errorf("content rewriting deletion failed with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+
+	resJSON := struct{ Payload int }{}
+	err = json.Unmarshal(body, &resJSON)
+	if err != nil {
+		return err
+	}
+
+	if resJSON.Payload != 0 {
+		return fmt.Errorf("content rewriting deletion failed: %s", getErrorMessage(resJSON.Payload))
+	}
+
+	return nil
+}
diff --git a/loadbalance_content_rewriting_condition.go b/loadbalance_content_rewriting_condition.go
new file mode 100644
index 0000000..266a29c
--- /dev/null
+++ b/loadbalance_content_rewriting_condition.go
@@ -0,0 +1,279 @@
+package gofortiadc
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+)
+
+// LoadbalanceContentRewritingCondition represents a content rewriting condition request/response
+type LoadbalanceContentRewritingCondition struct {
+	Mkey       string `json:"mkey"`
+	Content    string `json:"content"`
+	Ignorecase string `json:"ignorecase"`
+	Object     string `json:"object"`
+	Reverse    string `json:"reverse"`
+	Type       string `json:"type"`
+}
+
+// LoadbalanceGetContentRewritingConditions returns the list of all content rewriting conditions
+func (c *Client) LoadbalanceGetContentRewritingConditions(cr string) ([]LoadbalanceContentRewritingCondition, error) {
+	req, err := c.NewRequest("GET", fmt.Sprintf("%s/api/load_balance_content_rewriting_child_match_condition?pkey=%s", c.Address, cr), nil)
+	if err != nil {
+		return []LoadbalanceContentRewritingCondition{}, err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return []LoadbalanceContentRewritingCondition{}, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return []LoadbalanceContentRewritingCondition{}, fmt.Errorf("failed to get content rewriting conditions list with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return []LoadbalanceContentRewritingCondition{}, err
+	}
+
+	var LoadbalanceContentRewritingConditionPayload struct {
+		Payload []LoadbalanceContentRewritingCondition
+	}
+	err = json.Unmarshal(body, &LoadbalanceContentRewritingConditionPayload)
+	if err != nil {
+		return []LoadbalanceContentRewritingCondition{}, err
+	}
+
+	return LoadbalanceContentRewritingConditionPayload.Payload, nil
+}
+
+// LoadbalanceGetContentRewritingCondition returns a content rewriting condition by name
+func (c *Client) LoadbalanceGetContentRewritingCondition(cr, mkey string) (LoadbalanceContentRewritingCondition, error) {
+	req, err := c.NewRequest("GET", fmt.Sprintf("%s/api/load_balance_content_rewriting_child_match_condition?pkey=%s", c.Address, cr), nil)
+	if err != nil {
+		return LoadbalanceContentRewritingCondition{}, err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return LoadbalanceContentRewritingCondition{}, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return LoadbalanceContentRewritingCondition{}, fmt.Errorf("failed to get content rewriting conditions list with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return LoadbalanceContentRewritingCondition{}, err
+	}
+
+	var LoadbalanceContentRewritingConditionPayload struct {
+		Payload []LoadbalanceContentRewritingCondition
+	}
+	err = json.Unmarshal(body, &LoadbalanceContentRewritingConditionPayload)
+	if err != nil {
+		return LoadbalanceContentRewritingCondition{}, err
+	}
+
+	for _, cr := range LoadbalanceContentRewritingConditionPayload.Payload {
+		if cr.Mkey == mkey {
+			return cr, nil
+		}
+	}
+
+	return LoadbalanceContentRewritingCondition{}, fmt.Errorf("content rewriting condition %s not found", mkey)
+}
+
+// LoadbalanceGetContentRewritingConditionID returns a content rewriting condition ID by request
+func (c *Client) LoadbalanceGetContentRewritingConditionID(cr string, obj LoadbalanceContentRewritingCondition) (string, error) {
+	req, err := c.NewRequest("GET", fmt.Sprintf("%s/api/load_balance_content_rewriting_child_match_condition?pkey=%s", c.Address, cr), nil)
+	if err != nil {
+		return "", err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return "", fmt.Errorf("failed to get content rewriting conditions list with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", err
+	}
+
+	var LoadbalanceContentRewritingConditionPayload struct {
+		Payload []LoadbalanceContentRewritingCondition
+	}
+	err = json.Unmarshal(body, &LoadbalanceContentRewritingConditionPayload)
+	if err != nil {
+		return "", err
+	}
+
+	for _, cr := range LoadbalanceContentRewritingConditionPayload.Payload {
+		if cr.Content != obj.Content {
+			continue
+		}
+		if cr.Ignorecase != obj.Ignorecase {
+			continue
+		}
+		if cr.Object != obj.Object {
+			continue
+		}
+		if cr.Reverse != obj.Reverse {
+			continue
+		}
+		if cr.Type != obj.Type {
+			continue
+		}
+
+		return cr.Mkey, nil
+	}
+
+	return "", fmt.Errorf("content rewriting condition ID %+v not found", obj)
+}
+
+// LoadbalanceCreateContentRewritingCondition creates a new content rewriting condition
+func (c *Client) LoadbalanceCreateContentRewritingCondition(cr string, rc LoadbalanceContentRewritingCondition) error {
+
+	payloadJSON, err := json.Marshal(rc)
+	if err != nil {
+		return err
+	}
+
+	req, err := c.NewRequest(
+		"POST",
+		fmt.Sprintf("%s/api/load_balance_content_rewriting_child_match_condition?pkey=%s", c.Address, cr),
+		bytes.NewReader(payloadJSON),
+	)
+	if err != nil {
+		return err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return fmt.Errorf("content rewriting condition creation failed with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+
+	resJSON := struct{ Payload int }{}
+	err = json.Unmarshal(body, &resJSON)
+	if err != nil {
+		return err
+	}
+
+	if resJSON.Payload != 0 {
+		return fmt.Errorf("content rewriting condition creation failed: %s ", getErrorMessage(resJSON.Payload))
+	}
+
+	return nil
+}
+
+// LoadbalanceUpdateContentRewritingCondition updates an existing content rewriting condition
+func (c *Client) LoadbalanceUpdateContentRewritingCondition(cr string, rd LoadbalanceContentRewritingCondition) error {
+
+	payloadJSON, err := json.Marshal(rd)
+	if err != nil {
+		return err
+	}
+
+	req, err := c.NewRequest(
+		"PUT",
+		fmt.Sprintf("%s/api/load_balance_content_rewriting_child_match_condition?mkey=%s&pkey=%s", c.Address, rd.Mkey, cr),
+		bytes.NewReader(payloadJSON),
+	)
+	if err != nil {
+		return err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return fmt.Errorf("content rewriting condition update failed with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(body))
+
+	resJSON := struct{ Payload int }{}
+	err = json.Unmarshal(body, &resJSON)
+	if err != nil {
+		return err
+	}
+
+	if resJSON.Payload != 0 {
+		return fmt.Errorf("content rewriting condition update failed: %s", getErrorMessage(resJSON.Payload))
+	}
+
+	return nil
+}
+
+// LoadbalanceDeleteContentRewritingCondition deletes an existing content rewriting
+func (c *Client) LoadbalanceDeleteContentRewritingCondition(cr, mkey string) error {
+
+	if len(mkey) == 0 {
+		return errors.New("content rewriting condition mkey cannot be empty")
+	}
+
+	req, err := c.NewRequest(
+		"DELETE",
+		fmt.Sprintf("%s/api/load_balance_content_rewriting_child_match_condition?mkey=%s&pkey=%s", c.Address, mkey, cr),
+		nil,
+	)
+	if err != nil {
+		return err
+	}
+
+	res, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return fmt.Errorf("content rewriting condition deletion failed with status code: %d", res.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+
+	resJSON := struct{ Payload int }{}
+	err = json.Unmarshal(body, &resJSON)
+	if err != nil {
+		return err
+	}
+
+	if resJSON.Payload != 0 {
+		return fmt.Errorf("content rewriting condition deletion failed: %s", getErrorMessage(resJSON.Payload))
+	}
+
+	return nil
+}
diff --git a/loadbalance_content_rewriting_condition_test.go b/loadbalance_content_rewriting_condition_test.go
new file mode 100644
index 0000000..f3210f7
--- /dev/null
+++ b/loadbalance_content_rewriting_condition_test.go
@@ -0,0 +1,135 @@
+package gofortiadc
+
+import (
+	"fmt"
+	"os"
+	"testing"
+)
+
+func TestClient_LoadbalanceGetContentRewritingConditions(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	res, err := client.LoadbalanceGetContentRewritingConditions("gofortirw01")
+	if err != nil {
+		t.Logf("%+v", res)
+		t.Fatal(err)
+	}
+}
+
+func TestClient_LoadbalanceGetContentRewritingCondition(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = client.LoadbalanceGetContentRewritingCondition("gofortirw01", "1")
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestClient_LoadbalanceCreateContentRewritingCondition(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req := LoadbalanceContentRewritingCondition{
+		Mkey:       "",
+		Content:    "match",
+		Ignorecase: "enable",
+		Object:     "http-host-header",
+		Reverse:    "disable",
+		Type:       "string",
+	}
+
+	err = client.LoadbalanceCreateContentRewritingCondition("gofortirw01", req)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestClient_LoadbalanceGetContentRewritingConditionID(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req := LoadbalanceContentRewritingCondition{
+		Mkey:       "",
+		Content:    "match",
+		Ignorecase: "enable",
+		Object:     "http-host-header",
+		Reverse:    "disable",
+		Type:       "string",
+	}
+
+	id, err := client.LoadbalanceGetContentRewritingConditionID("gofortirw01", req)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if id != "1" {
+		t.Fatal(fmt.Errorf("id should be 1 but has a value of %s", id))
+	}
+}
+
+func TestClient_LoadbalanceUpdateContentRewritingCondition(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req := LoadbalanceContentRewritingCondition{
+		Mkey:       "1",
+		Content:    "127.0.0.1",
+		Ignorecase: "disable",
+		Object:     "ip-source-address",
+		Reverse:    "disable",
+		Type:       "string",
+	}
+
+	err = client.LoadbalanceUpdateContentRewritingCondition("gofortirw01", req)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestClient_Client_LoadbalanceDeleteContentRewritingCondition(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = client.LoadbalanceDeleteContentRewritingCondition("gofortirw01", "1")
+	if err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/loadbalance_content_rewriting_test.go b/loadbalance_content_rewriting_test.go
new file mode 100644
index 0000000..117822a
--- /dev/null
+++ b/loadbalance_content_rewriting_test.go
@@ -0,0 +1,115 @@
+package gofortiadc
+
+import (
+	"os"
+	"testing"
+)
+
+func TestClient_LoadbalanceGetContentRewritings(t *testing.T) {
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	res, err := client.LoadbalanceGetContentRewritings()
+	if err != nil {
+		t.Logf("%+v", res)
+		t.Fatal(err)
+	}
+}
+
+func TestClient_LoadbalanceGetContentRewriting(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = client.LoadbalanceGetContentRewriting("gofortirw01")
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestClient_LoadbalanceCreateContentRewriting(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req := LoadbalanceContentRewriting{
+		Mkey:           "gofortirw01",
+		ActionType:     "request",
+		URLStatus:      "enable",
+		URLContent:     "/url",
+		RefererStatus:  "enable",
+		RefererContent: "http://",
+		Redirect:       "redirect",
+		Location:       "http://",
+		HeaderName:     "header-name",
+		Comments:       "",
+		Action:         "rewrite_http_header",
+		HostStatus:     "enable",
+		HostContent:    "host",
+	}
+
+	err = client.LoadbalanceCreateContentRewriting(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestClient_LoadbalanceUpdateContentRewriting(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req := LoadbalanceContentRewriting{
+		Mkey:           "gofortirw01",
+		ActionType:     "request",
+		URLStatus:      "disable",
+		URLContent:     "/url",
+		RefererStatus:  "enable",
+		RefererContent: "http://foo.bar",
+		Redirect:       "redirect",
+		Location:       "http://",
+		HeaderName:     "header-name",
+		Comments:       "",
+		Action:         "rewrite_http_header",
+		HostStatus:     "disable",
+		HostContent:    "host",
+	}
+
+	err = client.LoadbalanceUpdateContentRewriting(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestClient_Client_LoadbalanceDeleteContentRewriting(t *testing.T) {
+	if os.Getenv("TEST_LENS") != "true" {
+		t.Skip()
+	}
+
+	client, err := NewClientHelper()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = client.LoadbalanceDeleteContentRewriting("gofortirw01")
+	if err != nil {
+		t.Fatal(err)
+	}
+}