How to Transfer WriteSonic Content to Jasper AI Brand Voice

If you have been building content in WriteSonic and now need to use Jasper AI’s Brand Voice feature for consistent tone and style across your content, you need a clear migration path. This guide walks you through extracting your WriteSonic content, converting it to a format Jasper AI can consume, and setting up Brand Voice to maintain your established writing style.

Why Transfer Content to Jasper AI Brand Voice

WriteSonic excels at generating SEO-optimized marketing copy with its AI-powered tools. However, Jasper AI offers a more structured approach to brand consistency through its Brand Voice feature. When you need multiple team members producing content that matches your established tone, vocabulary, and style, Jasper AI’s Brand Voice provides that consistency at scale.

The迁移 process involves three main steps: exporting your WriteSonic content, analyzing that content to extract style characteristics, and configuring Jasper AI Brand Voice with those characteristics.

Step 1: Export Your WriteSonic Content

WriteSonic does not provide a bulk export feature through its UI, but you can retrieve your content programmatically using their API. Here’s how to export your documents:

Using the WriteSonic API

import requests
import json
import os

def get_writesonic_content(api_key, folder_id=None):
    """
    Fetch all content from WriteSonic using their API.
    """
    url = "https://api.writesonic.com/v1/content/history"

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }

    params = {"limit": 100}
    if folder_id:
        params["folder_id"] = folder_id

    response = requests.get(url, headers=headers, params=params)

    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

# Usage
api_key = os.environ.get("WRITESONIC_API_KEY")
content_data = get_writesonic_content(api_key)

# Save to file for analysis
with open("writesonic_exports.json", "w") as f:
    json.dump(content_data, f, indent=2)

This script retrieves up to 100 items from your WriteSonic history. For larger accounts, you will need to implement pagination using the offset parameter.

Manual Export Alternative

If you prefer manual export, you can access individual documents through the WriteSonic dashboard:

Log into your WriteSonic account
Navigate to the “Content” section
Open each document you want to transfer
Copy the content to a local file

For bulk manual export, consider using browser automation with Playwright:

from playwright.sync_api import sync_playwright
import json

def export_all_content(username, password):
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()

        # Login (simplified - add proper selectors)
        page.goto("https://app.writesonic.com/login")
        page.fill('input[name="email"]', username)
        page.fill('input[name="password"]', password)
        page.click('button[type="submit"]')
        page.wait_for_load_state("networkidle")

        # Navigate to content library
        page.click('a[href="/content"]')
        page.wait_for_load_state("networkidle")

        content_items = []

        # Extract visible content (requires scrolling and pagination)
        while True:
            items = page.query_selector_all('.content-item')
            for item in items:
                content_items.append({
                    "title": item.query_selector('.title').inner_text(),
                    "body": item.query_selector('.body').inner_text()
                })

            # Check for next page button
            next_btn = page.query_selector('button.next-page')
            if next_btn and next_btn.is_enabled():
                next_btn.click()
                page.wait_for_load_state("networkidle")
            else:
                break

        browser.close()
        return content_items

Step 2: Analyze Content for Style Characteristics

Once you have exported your WriteSonic content, you need to extract the style characteristics that define your brand voice. This involves analyzing tone, vocabulary, sentence structure, and formatting patterns.

Extracting Style Metrics

import re
from collections import Counter

def analyze_writing_style(content_list):
    """
    Analyze WriteSonic exports to extract brand voice characteristics.
    """
    all_text = " ".join([item["body"] for item in content_list if item.get("body")])

    # Basic metrics
    sentences = re.split(r'[.!?]+', all_text)
    sentences = [s.strip() for s in sentences if s.strip()]

    words = all_text.split()
    avg_sentence_length = len(words) / max(len(sentences), 1)

    # Vocabulary analysis
    word_freq = Counter(words)
    unique_words = len(set(words))
    lexical_diversity = unique_words / max(len(words), 1)

    # Tone indicators
    formal_words = ["therefore", "furthermore", "moreover", "consequently", "accordingly"]
    casual_words = ["really", "basically", "actually", "pretty", "thing"]

    formal_count = sum(1 for w in words if w.lower() in formal_words)
    casual_count = sum(1 for w in words if w.lower() in casual_words)

    # Formatting patterns
    headings = len(re.findall(r'^#+ ', all_text, re.MULTILINE))
    lists = len(re.findall(r'^\s*[-*•]\s+', all_text, re.MULTILINE))

    return {
        "avg_sentence_length": round(avg_sentence_length, 2),
        "lexical_diversity": round(lexical_diversity, 3),
        "total_words": len(words),
        "formal_indicator": formal_count / max(len(sentences), 1),
        "casual_indicator": casual_count / max(len(sentences), 1),
        "headings_count": headings,
        "lists_count": lists,
        "sample_content": all_text[:5000]  # First 5000 chars for Jasper
    }

# Usage
with open("writesonic_exports.json", "r") as f:
    content_data = json.load(f)

style_analysis = analyze_writing_style(content_data)
print(json.dumps(style_analysis, indent=2))

This analysis gives you quantified metrics about your writing style. Use these numbers when configuring Jasper AI Brand Voice.

Step 3: Configure Jasper AI Brand Voice

Now you can transfer your WriteSonic style to Jasper AI. Jasper Brand Voice works by uploading sample content that represents your brand style. Jasper then analyzes this content to understand your tone, vocabulary, and formatting preferences.

Uploading Sample Content via API

Jasper provides an API for managing Brand Voice. Here is how to upload your analyzed content:

def setup_jasper_brand_voice(api_key, brand_name, sample_content):
    """
    Create a Brand Voice in Jasper AI using analyzed content from WriteSonic.
    """
    url = "https://api.jasper.ai/v1/brand-voice"

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "name": brand_name,
        "description": "Brand voice migrated from WriteSonic content",
        "sample_content": sample_content,
        "tone": "custom",
        "style_preferences": {
            "sentence_length": "varies",
            "vocabulary_level": "professional",
            "formatting": "headings_and_lists"
        }
    }

    response = requests.post(url, headers=headers, json=payload)

    if response.status_code in [200, 201]:
        return response.json()
    else:
        print(f"Error: {response.status_code}")
        print(response.text)
        return None

# Usage
jasper_api_key = os.environ.get("JASPER_API_KEY")
brand_voice = setup_jasper_brand_voice(
    jasper_api_key,
    "Migrated Brand Voice",
    style_analysis["sample_content"]
)

Manual Configuration Through UI

If you prefer the UI approach:

Log into Jasper AI
Navigate to Settings > Brand Voice
Click “Create New Brand Voice”
Upload your WriteSonic content samples (recommended: 5-10 documents)
Jasper will analyze and extract:

Tone and voice patterns
Industry-specific vocabulary
Formatting preferences
Sentence structure variations

Step 4: Validate the Migration

After setting up Brand Voice, test it with a sample prompt similar to your WriteSonic content:

def test_brand_voice(api_key, brand_voice_id, test_prompt):
    """
    Test that Jasper Brand Voice matches your WriteSonic style.
    """
    url = "https://api.jasper.ai/v1/generate"

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "brand_voice_id": brand_voice_id,
        "prompt": test_prompt,
        "max_tokens": 500,
        "temperature": 0.7
    }

    response = requests.post(url, headers=headers, json=payload)
    return response.json() if response.status_code == 200 else None

# Test prompt matching your WriteSonic content type
test_result = test_brand_voice(
    jasper_api_key,
    brand_voice["id"],
    "Write a product description for a new SaaS tool"
)

Compare the output against your original WriteSonic content. Adjust the Brand Voice sample content or settings if the tone diverges significantly.

Handling Content Differences

WriteSonic and Jasper AI use different underlying models and training approaches. Some adjustments may be necessary:

Vocabulary preservation: Add specific industry terms to Jasper’s Brand Voice “custom words” list
Formatting conventions: Explicitly specify heading styles and list formats in Brand Voice settings
Tone calibration: If the output feels too different, upload additional sample content from WriteSonic

Built by theluckystrike — More at zovo.one