Using the create and publish fails in a onsite Sharepoint

[Jose-albino]

I am trying to deploy this code in a onsite sharepoint 2019 with REST API using NTLM authentication i am able to list the pages
but i can't create and publish a modern page.

I created this code from your example

What works

• I can list the paces
• I can upload a page.aspx

What fails:

• Creating a modern page.

With this error.
'''
office365.runtime.client_request_exception.ClientRequestException: ('-1, Microsoft.Data.OData.ODataException', "La propriété 'CoAuthState' n'existe pas sur le type 'SP.Publishing.SitePageFieldsData'. Assurez-vous que vous utilisez uniquement des noms de propriété qui sont définis par le type.")
'''

My code

"""

This module provides NTLM authentication methods for on-premises SharePoint servers:
- NTLM authentication via office365-rest library
- Custom session with NTLM authentication via requests-ntlm

Environment Variables:
    SHAREPOINT_SITE_URL: SharePoint site URL (e.g., https://sharepoint.internal.company.com/sites/mysite)
    SHAREPOINT_DOMAIN: Windows domain name (e.g., COMPANY)
    SHAREPOINT_USERNAME: Windows username (without domain prefix)
    SHAREPOINT_PASSWORD: Windows password
    SHAREPOINT_AUTH_METHOD: Authentication method: "ntlm" (default) or "session"
"""

import os
import logging
from pathlib import Path
from typing import Optional

from dotenv import load_dotenv
from office365.sharepoint.client_context import ClientContext

logger = logging.getLogger(__name__)


def load_environment():
    """Load environment variables from .env file if available."""
    # Try to load from project root .env file
    env_path = Path(__file__).parent.parent.parent / ".env"
    if env_path.exists():
        load_dotenv(dotenv_path=str(env_path))
        logger.info(f"Loaded environment from {env_path}")
    else:
        logger.warning(".env file not found, using system environment variables")


def get_env_variable(name: str, required: bool = False) -> Optional[str]:
    """Get an environment variable with fallback."""
    value = os.environ.get(name)
    if required and not value:
        raise ValueError(f"Required environment variable {name} is not set")
    return value


def create_client_with_ntlm(site_url: str, username: str, password: str) -> ClientContext:
    """
    Create a SharePoint client context using NTLM authentication.
    
    This method is typically used for on-premises SharePoint servers.
    
    Args:
        site_url: SharePoint site URL
        username: Windows username in format DOMAIN\\username
        password: Windows password
        
    Returns:
        ClientContext: Authenticated SharePoint client context
    """
    ctx = ClientContext(site_url, allow_ntlm=True).with_user_credentials(username, password)
    return ctx


def create_client_with_session(site_url: str, username: str, password: str) -> ClientContext:
    """
    Create a SharePoint client context using a custom session with NTLM authentication.
    
    This method provides more control over the HTTP session settings.
    
    Args:
        site_url: SharePoint site URL
        username: Windows username in format DOMAIN\\username
        password: Windows password
        
    Returns:
        ClientContext: Authenticated SharePoint client context
    """
    import requests
    import requests_ntlm
    import urllib3

    urllib3.disable_warnings()

    session = requests.Session()
    session.verify = False  # Disable SSL verification for internal servers
    session.auth = requests_ntlm.HttpNtlmAuth(username, password)
    
    ctx = ClientContext(site_url).with_transport(session=session)
    return ctx


def create_client(auth_method: str = "ntlm", **kwargs) -> ClientContext:
    """
    Factory function to create a SharePoint client context with NTLM authentication.
    
    Args:
        auth_method: Authentication method to use:
            - "ntlm": NTLM authentication via office365-rest library (default)
            - "session": Custom session with NTLM authentication via requests-ntlm
        **kwargs: Additional arguments (site_url, username, password)
        
    Returns:
        ClientContext: Authenticated SharePoint client context
    """
    if auth_method == "ntlm":
        return create_client_with_ntlm(
            site_url=kwargs.get("site_url"),
            username=kwargs.get("username"),
            password=kwargs.get("password")
        )
    elif auth_method == "session":
        return create_client_with_session(
            site_url=kwargs.get("site_url"),
            username=kwargs.get("username"),
            password=kwargs.get("password")
        )
    else:
        raise ValueError(f"Unknown authentication method: {auth_method}. Supported: 'ntlm', 'session'")




def create_modern_page(ctx: ClientContext, title: str) -> str:
    """
    Create a modern SharePoint page using SitePageService.
    
    This creates a draft page in the Site Pages library using the modern page API.
    The page is created as a draft and needs to be published separately.
    
    Args:
        ctx: Authenticated SharePoint client context
        title: Title of the page to create
        
    Returns:
        str: Absolute URL of the created page
    """
    page = ctx.site_pages.create_page(title).execute_query()
    logger.info(f"Modern page created: {page.absolute_url}")
    return page.absolute_url


def create_and_publish_modern_page(ctx: ClientContext, title: str) -> str:
    """
    Create and publish a modern SharePoint page in one step.
    
    This creates and immediately publishes a page in the Site Pages library
    using the modern page API.
    
    Args:
        ctx: Authenticated SharePoint client context
        title: Title of the page to create and publish
        
    Returns:
        str: Absolute URL of the published page
    """
    page = ctx.site_pages.create_and_publish_page(title).execute_query()
    logger.info(f"Modern page published: {page.absolute_url}")
    return page.absolute_url


def list_site_pages(ctx: ClientContext, page_size: int = 5) -> list:
    """
    Page through all site pages in the Site Pages library.

    The ``SP.Publishing.SitePageService/pages`` endpoint does not return a
    server-side next link (unlike the classic list REST API), so paging falls
    back to client-driven offset requests automatically: ``paged(page_size)``
    keeps fetching subsequent pages via ``$skip`` until a short/empty page.

    Args:
        ctx: Authenticated SharePoint client context
        page_size: Number of pages per request (default: 5)

    Returns:
        list: List of all site page objects
    """
    pages = ctx.site_pages.pages.paged(page_size).get().execute_query()
    result = list(pages)
    logger.info(f"Retrieved {len(result)} site pages")
    return result


def verify_connection(ctx: ClientContext) -> bool:
    """
    Verify the connection to SharePoint by retrieving the web information.
    
    Args:
        ctx: SharePoint client context to verify
        
    Returns:
        bool: True if connection is successful
    """
    try:
        web = ctx.web.get().execute_query()
        logger.info(f"Connected to SharePoint site: {web.url}")
        return True
    except Exception as e:
        logger.error(f"Failed to connect to SharePoint: {e}")
        return False


def main():
    """Main entry point for the upload script."""
    # Configure logging
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )
    
    # Load environment variables
    load_environment()
    
    # Get required environment variables
    site_url = get_env_variable("SHAREPOINT_SITE_URL", required=True)
    auth_method = get_env_variable("SHAREPOINT_AUTH_METHOD", required=False) or "ntlm"
    domain = get_env_variable("SHAREPOINT_DOMAIN", required=True)
    username = get_env_variable("SHAREPOINT_USERNAME", required=True)
    password = get_env_variable("SHAREPOINT_PASSWORD", required=True)
    
    # Format username as DOMAIN\username for NTLM
    ntlm_username = f"{domain}\\{username}"
    
    # Create client with NTLM authentication
    ctx = create_client(
        auth_method=auth_method,
        site_url=site_url,
        username=ntlm_username,
        password=password,
    )
    
    # Verify connection
    if not verify_connection(ctx):
        logger.error("Connection verification failed. Please check your credentials.")
        return
    
    logger.info("Authentication successful!")
    logger.info("")
    logger.info("SharePoint has two page types:")
    logger.info("  1. Classic pages (ASPX files) - use upload_file() for legacy web part pages")
    logger.info("  2. Modern pages (HTML) - use create_modern_page() for new responsive pages")
    logger.info("")
    
    # Example 1: Upload a classic ASPX file to Site Pages library
    # Uncomment and modify the following lines to upload a classic ASPX file:
    file_path = "output\\Test-Page-with-text.aspx"
    folder_title = "Site Pages"
    upload_file(ctx, file_path, folder_title)
    
    # Example 2: Create a modern page (draft)
    # Uncomment and modify the following line to create a modern page draft:
    # create_modern_page(ctx, "My Modern Page")
    
    # Example 3: Create and publish a modern page in one step
    # Uncomment and modify the following line to create and publish a modern page:
    # create_and_publish_modern_page(ctx, "My Published Modern Page")

    # Example 4: List all site pages with pagination
    # Uncomment and modify the following lines to list all site pages:
    # page_size = 5  # pages per request
    # pages = list_site_pages(ctx, page_size)
    # for page in pages:
    #     logger.info(f"  {page.file_name}")
    # logger.info(f"Total site pages: {len(pages)}")


if __name__ == "__main__":
    main()

[Jose-albino]

@vgrem i am not able to understand if this is a bug or not.

[vgrem]

Thanks for the report and the detailed example! The root cause appears to be a server-side schema mismatch between versions:  SitePageFieldsData  sends all its members, including  CoAuthState , which SharePoint Online's type has but 2019's doesn't.

The fix is to send only the members that are set, and I'm looking into it for an upcoming release.

Until then, uploading the page as  .aspx , which already works for you, is the easiest workaround.

[Jose-albino]

IS there a way that i can use the package and this command to actually generate the page .aspx as a file and leveraging the correct webparts? The goal is to find list that are already existing in the Sharepoint and create a .aspx where i can provide a customized view of the list ?

Can we make the .aspx as output and then make the upload of file.

[vgrem]

Fixed in 3.3.1 (released 2026-11-07) — please upgrade and retry:

pip install --upgrade office365-rest-python-client

The cause was on our side. The draft-save request behind create_page() (save_draft()
builds a SitePageFieldsData) serialised every member of the type, so a create that set
only a title still carried a CoAuthState with nothing in it — and a farm whose type has
no such property rejects the whole request, which is your error:

version	body of the SaveDraft request
≤ 3.3.0	{"Title": "x", "CoAuthState": {}}
≥ 3.3.1	{"Title": "x"}

ClientValue.to_json() now omits a nested value whose members are all unset.
create_page() and create_and_publish_page() both go through that one request, so both
were affected and both are fixed. Stated plainly: I could reproduce the payload, not your
2019 farm — those two bodies are the evidence. If it still refuses, reopen this and paste
the new error.

On your follow-up (generating the .aspx yourself with a list view): the library uploads
a file you authored —

ctx.web.get_folder_by_server_relative_url("/sites/x/SitePages").upload_file(...).execute_query()
ctx.web.get_folder_by_server_relative_url("/sites/x/SitePages").files.add("Page.aspx", html).execute_query()

— and it can create a modern page from a canvas you supply:

page = ctx.site_pages.create_page("My Page").execute_query()
page.save_page("My Page", canvas_content=canvas).execute_query()

What it does not do is generate page markup. CanvasContent1 is a JSON canvas whose
blocks reference web parts by id; for "a customized view of an existing list" the block you
want is a list web part bound to that list's id, and that JSON is yours to build — the
library's parse_canvas_controls() / count_web_parts() only read an existing canvas.
So: yes to uploading a file, yes to creating a modern page with a canvas, no to emitting
classic web-part .aspx markup.