n8n-nodes-upload-post 0.1.56 → 0.4.0

package/dist/nodes/UploadPost/UploadPost.node.js

@@ -159,6 +159,7 @@ const FIRST_COMMENT_OVERRIDES = [
     { platform: 'reddit', param: 'redditFirstComment', field: 'reddit_first_comment' },
     { platform: 'bluesky', param: 'blueskyFirstComment', field: 'bluesky_first_comment' },
     { platform: 'linkedin', param: 'linkedinFirstComment', field: 'linkedin_first_comment' },
+    { platform: 'tiktok', param: 'tiktokFirstComment', field: 'tiktok_first_comment', operations: ['uploadPhotos', 'uploadVideo'] },
 ];
 const getFilteredPlatforms = (operation, platforms) => {
     var _a;
@@ -394,6 +395,20 @@ const applyFacebookOptions = (ctx, operation, formData, isManualPlatform = false
         }
     }
 };
+const applySharedTiktokFields = (ctx, formData) => {
+    const musicId = ctx.node.getNodeParameter('tiktokMusicId', ctx.itemIndex, '');
+    if (musicId)
+        formData.tiktok_music_id = musicId;
+    const locationId = ctx.node.getNodeParameter('tiktokLocationId', ctx.itemIndex, '');
+    const locationName = ctx.node.getNodeParameter('tiktokLocationName', ctx.itemIndex, '');
+    if (locationId && locationName) {
+        formData.tiktok_location_id = locationId;
+        formData.tiktok_location_name = locationName;
+    }
+    const isAiGenerated = ctx.node.getNodeParameter('tiktokIsAiGenerated', ctx.itemIndex, false);
+    if (isAiGenerated)
+        formData.tiktok_is_ai_generated = 'true';
+};
 const applyTiktokOptions = (ctx, operation, formData) => {
     if (operation === 'uploadPhotos') {
         const autoAddMusic = ctx.node.getNodeParameter('tiktokAutoAddMusic', ctx.itemIndex, false);
@@ -410,6 +425,7 @@ const applyTiktokOptions = (ctx, operation, formData) => {
         if (photoDescription && formData.description === undefined) {
             formData.description = photoDescription;
         }
+        applySharedTiktokFields(ctx, formData);
     }
     else if (operation === 'uploadVideo') {
         const privacyLevel = ctx.node.getNodeParameter('tiktokPrivacyLevel', ctx.itemIndex, '');
@@ -432,6 +448,23 @@ const applyTiktokOptions = (ctx, operation, formData) => {
         formData.is_aigc = String(isAigc);
         if (postMode)
             formData.post_mode = postMode;
+        applySharedTiktokFields(ctx, formData);
+        if (formData.tiktok_music_id) {
+            formData.tiktok_music_volume = ctx.node.getNodeParameter('tiktokMusicVolume', ctx.itemIndex, 50);
+            formData.tiktok_original_sound_volume = ctx.node.getNodeParameter('tiktokOriginalSoundVolume', ctx.itemIndex, 50);
+            const musicStart = ctx.node.getNodeParameter('tiktokMusicStart', ctx.itemIndex, 0);
+            const musicEnd = ctx.node.getNodeParameter('tiktokMusicEnd', ctx.itemIndex, 0);
+            if (musicStart > 0)
+                formData.tiktok_music_start = musicStart;
+            if (musicEnd > 0)
+                formData.tiktok_music_end = musicEnd;
+        }
+        const coverImageUrl = ctx.node.getNodeParameter('tiktokCoverImageUrl', ctx.itemIndex, '');
+        if (coverImageUrl)
+            formData.tiktok_cover_image_url = coverImageUrl;
+        const uploadToDraft = ctx.node.getNodeParameter('tiktokUploadToDraft', ctx.itemIndex, false);
+        if (uploadToDraft)
+            formData.tiktok_upload_to_draft = 'true';
     }
 };
 const applyInstagramOptions = async (ctx, operation, formData) => {
@@ -1234,18 +1267,28 @@ const buildUserRequest = async (ctx) => {
             });
     }
 };
+const COMMENT_ACTIONS_WITHOUT_POST = new Set(['like', 'unlike']);
 const buildInstagramRequest = (ctx) => {
     switch (ctx.operation) {
         case 'getPostComments': {
             const user = ctx.node.getNodeParameter('instagramUser', ctx.itemIndex);
+            const platform = ctx.node.getNodeParameter('commentPlatform', ctx.itemIndex, 'instagram');
             const postId = ctx.node.getNodeParameter('instagramPostId', ctx.itemIndex);
-            const qs = { platform: 'instagram', user };
+            const qs = { platform, user };
             if (postId.startsWith('http://') || postId.startsWith('https://')) {
+                if (platform === 'tiktok') {
+                    throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), 'TikTok comments are looked up by video ID, not by URL. Paste the numeric video ID instead.', {
+                        itemIndex: ctx.itemIndex,
+                    });
+                }
                 qs.post_url = postId;
             }
             else {
                 qs.post_id = postId;
             }
+            const commentId = ctx.node.getNodeParameter('commentsCommentId', ctx.itemIndex, '');
+            if (commentId)
+                qs.comment_id = commentId;
             return {
                 endpoint: '/uploadposts/comments',
                 method: 'GET',
@@ -1278,12 +1321,91 @@ const buildInstagramRequest = (ctx) => {
                 waitForCompletion: false,
             };
         }
+        case 'commentAction': {
+            const user = ctx.node.getNodeParameter('instagramUser', ctx.itemIndex);
+            const platform = ctx.node.getNodeParameter('commentActionPlatform', ctx.itemIndex, 'tiktok');
+            const action = ctx.node.getNodeParameter('commentModerationAction', ctx.itemIndex);
+            const body = {
+                platform,
+                user,
+                comment_id: ctx.node.getNodeParameter('instagramCommentId', ctx.itemIndex),
+                action,
+            };
+            if (!COMMENT_ACTIONS_WITHOUT_POST.has(action)) {
+                const postId = ctx.node.getNodeParameter('commentActionPostId', ctx.itemIndex, '');
+                if (!postId) {
+                    throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `A Post ID is required to ${action} a comment.`, {
+                        itemIndex: ctx.itemIndex,
+                    });
+                }
+                body.post_id = postId;
+            }
+            return {
+                endpoint: '/uploadposts/comments/action',
+                method: 'POST',
+                body,
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
         default:
             throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `Unsupported Instagram operation: ${ctx.operation}`, {
                 itemIndex: ctx.itemIndex,
             });
     }
 };
+const buildInsightsRequest = (ctx) => {
+    const user = ctx.node.getNodeParameter('insightsUser', ctx.itemIndex);
+    const platform = ctx.node.getNodeParameter('insightsPlatform', ctx.itemIndex, 'tiktok');
+    switch (ctx.operation) {
+        case 'getAudience': {
+            const qs = { user, platform };
+            const startDate = ctx.node.getNodeParameter('audienceStartDate', ctx.itemIndex, '');
+            if (startDate)
+                qs.start_date = startDate.slice(0, 10);
+            const endDate = ctx.node.getNodeParameter('audienceEndDate', ctx.itemIndex, '');
+            if (endDate)
+                qs.end_date = endDate.slice(0, 10);
+            const benchmarkCategory = ctx.node.getNodeParameter('audienceBenchmarkCategory', ctx.itemIndex, '');
+            if (benchmarkCategory)
+                qs.benchmark_category = benchmarkCategory;
+            return {
+                endpoint: '/uploadposts/audience',
+                method: 'GET',
+                qs,
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        case 'getSuggestions': {
+            const qs = {
+                user,
+                platform,
+                type: ctx.node.getNodeParameter('suggestionsType', ctx.itemIndex),
+            };
+            const query = ctx.node.getNodeParameter('suggestionsQuery', ctx.itemIndex, '');
+            if (query)
+                qs.q = query;
+            const countryCode = ctx.node.getNodeParameter('suggestionsCountryCode', ctx.itemIndex, '');
+            if (countryCode)
+                qs.country_code = countryCode;
+            const language = ctx.node.getNodeParameter('suggestionsLanguage', ctx.itemIndex, '');
+            if (language)
+                qs.language = language;
+            return {
+                endpoint: '/uploadposts/suggestions',
+                method: 'GET',
+                qs,
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
+        default:
+            throw new n8n_workflow_1.NodeOperationError(ctx.node.getNode(), `Unsupported insights operation: ${ctx.operation}`, {
+                itemIndex: ctx.itemIndex,
+            });
+    }
+};
 const buildRequestConfig = async (ctx) => {
     if (ctx.operation === 'uploadPhotos') {
         return buildUploadPhotosRequest(ctx);
@@ -1301,6 +1423,9 @@ const buildRequestConfig = async (ctx) => {
     if (resource === 'instagram') {
         return buildInstagramRequest(ctx);
     }
+    if (resource === 'insights') {
+        return buildInsightsRequest(ctx);
+    }
     if (resource === 'monitoring') {
         return buildMonitoringRequest(ctx);
     }
@@ -1404,9 +1529,10 @@ class UploadPost {
                     type: 'options',
                     noDataExpression: true,
                     options: [
-                        { name: 'Upload', value: 'uploads' },
-                        { name: 'Instagram', value: 'instagram' },
+                        { name: 'Comment', value: 'instagram' },
+                        { name: 'Insight', value: 'insights' },
                         { name: 'Status & History', value: 'monitoring' },
+                        { name: 'Upload', value: 'uploads' },
                         { name: 'User', value: 'users' },
                     ],
                     default: 'uploads',
@@ -1437,7 +1563,7 @@ class UploadPost {
                         { name: 'Get Cached Post Analytics', value: 'getCachedPostAnalytics', action: 'Get cached post analytics', description: 'Replay per-post metrics already fetched for a profile instead of querying the platforms again, so it is not subject to the live analytics rate limit (100 requests / 5 minutes). Only contains posts previously fetched through Get Post Analytics; there is no background refresh, so captured_at is the last time that post was read live. Use Get Post Analytics to refresh a post, and this operation for bulk re-reads.' },
                         { name: 'Get Job Status', value: 'getJobStatus', action: 'Get job status', description: 'Check the status of a scheduled or queued post using the job_id' },
                         { name: 'Get Platform Metrics', value: 'getPlatformMetrics', action: 'Get platform metrics', description: 'List the analytics metrics available for each platform' },
-                        { name: 'Get Post Analytics', value: 'getPostAnalytics', action: 'Get post analytics', description: 'Retrieve per-post analytics for an upload using its request_id' },
+                        { name: 'Get Post Analytics', value: 'getPostAnalytics', action: 'Get post analytics', description: 'Retrieve per-post analytics for an upload using its request_id. On TikTok post_metrics also carries retention, impression_sources, audience_types, new_followers, reach and the watch times.' },
                         { name: 'Get Post Analytics by Platform ID', value: 'getPostAnalyticsByPlatformId', action: 'Get post analytics by platform id', description: 'Retrieve per-post analytics using the native platform post ID, for posts not published through Upload-Post' },
                         { name: 'Get Reddit Detailed Posts', value: 'getRedditDetailedPosts', action: 'Get reddit detailed posts', description: 'Retrieve detailed Reddit posts with full media information' },
                         { name: 'Get Total Impressions', value: 'getTotalImpressions', action: 'Get total impressions', description: 'Retrieve impressions aggregated across connected platforms for a date range' },
@@ -1473,9 +1599,10 @@ class UploadPost {
                     type: 'options',
                     noDataExpression: true,
                     options: [
-                        { name: 'Get Post Comments', value: 'getPostComments', action: 'Get post comments', description: 'Retrieve all comments on a specific Instagram post' },
-                        { name: 'Private Reply to Comment', value: 'privateReplyToComment', action: 'Private reply to comment', description: 'Send a private reply (DM) to the author of a comment' },
-                        { name: 'Public Reply to Comment', value: 'publicReplyToComment', action: 'Public reply to comment', description: 'Post a public reply visible under the original comment' },
+                        { name: 'Comment Action', value: 'commentAction', action: 'Act on a comment', description: 'Moderate one comment: hide, unhide, like, unlike, pin or unpin it. Platform says which connected network the comment lives on. Post ID is required to hide, unhide, pin or unpin, and is never sent for like or unlike.' },
+                        { name: 'Get Post Comments', value: 'getPostComments', action: 'Get post comments', description: 'Retrieve the comments on a post from the network given by Platform (Instagram, Facebook, YouTube, LinkedIn or TikTok). Fill Comment ID to get the replies to that comment instead of the top-level comments of the post.' },
+                        { name: 'Private Reply to Comment', value: 'privateReplyToComment', action: 'Private reply to comment', description: 'Send a private reply (DM) to the author of a comment. Instagram only.' },
+                        { name: 'Public Reply to Comment', value: 'publicReplyToComment', action: 'Public reply to comment', description: 'Post a public reply visible under the original comment. Instagram only.' },
                     ],
                     default: 'getPostComments',
                     displayOptions: { show: { resource: ['instagram'] } },
@@ -1492,7 +1619,40 @@ class UploadPost {
                     displayOptions: {
                         show: {
                             resource: ['instagram'],
-                            operation: ['getPostComments', 'privateReplyToComment', 'publicReplyToComment'],
+                            operation: ['getPostComments', 'privateReplyToComment', 'publicReplyToComment', 'commentAction'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Platform',
+                    name: 'commentPlatform',
+                    type: 'options',
+                    options: [
+                        { name: 'Facebook', value: 'facebook' },
+                        { name: 'Instagram', value: 'instagram' },
+                        { name: 'LinkedIn', value: 'linkedin' },
+                        { name: 'TikTok', value: 'tiktok' },
+                        { name: 'YouTube', value: 'youtube' },
+                    ],
+                    default: 'instagram',
+                    description: 'Network the post lives on. TikTok needs the "comments" capability on the profile (see the capabilities array returned by List Users); an account connected before that capability existed has to reconnect TikTok.',
+                    displayOptions: {
+                        show: {
+                            resource: ['instagram'],
+                            operation: ['getPostComments'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Comment ID',
+                    name: 'commentsCommentId',
+                    type: 'string',
+                    default: '',
+                    description: 'Leave empty for the top-level comments of the post. Set it to a comment ID to get the replies to that comment instead: it is the same question with one parameter more.',
+                    displayOptions: {
+                        show: {
+                            resource: ['instagram'],
+                            operation: ['getPostComments'],
                         },
                     },
                 },
@@ -1502,7 +1662,7 @@ class UploadPost {
                     type: 'string',
                     required: true,
                     default: '',
-                    description: 'Numeric media ID or full Instagram post URL (e.g., https://www.instagram.com/p/ABC123/)',
+                    description: 'Post identifier. Instagram and Facebook accept the numeric media ID or the post URL, YouTube the video ID, LinkedIn the post URN, TikTok the video ID (TikTok has no URL lookup).',
                     displayOptions: {
                         show: {
                             resource: ['instagram'],
@@ -1516,11 +1676,55 @@ class UploadPost {
                     type: 'string',
                     required: true,
                     default: '',
-                    description: 'The ID of the comment to reply to (from Get Post Comments)',
+                    description: 'The ID of the comment to reply to or act on (from Get Post Comments)',
                     displayOptions: {
                         show: {
                             resource: ['instagram'],
-                            operation: ['privateReplyToComment', 'publicReplyToComment'],
+                            operation: ['privateReplyToComment', 'publicReplyToComment', 'commentAction'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Platform',
+                    name: 'commentActionPlatform',
+                    type: 'options',
+                    required: true,
+                    options: [
+                        { name: 'TikTok', value: 'tiktok' },
+                    ],
+                    default: 'tiktok',
+                    description: 'Network the comment lives on. TikTok is the network that answers this question today; any other one replies with platform_not_supported and the list of the ones that can. On TikTok the profile needs the "comments" capability (see the capabilities array returned by List Users); an account connected before that capability existed has to reconnect TikTok.',
+                    displayOptions: { show: { resource: ['instagram'], operation: ['commentAction'] } },
+                },
+                {
+                    displayName: 'Action',
+                    name: 'commentModerationAction',
+                    type: 'options',
+                    required: true,
+                    options: [
+                        { name: 'Hide', value: 'hide' },
+                        { name: 'Like', value: 'like' },
+                        { name: 'Pin', value: 'pin' },
+                        { name: 'Unhide', value: 'unhide' },
+                        { name: 'Unlike', value: 'unlike' },
+                        { name: 'Unpin', value: 'unpin' },
+                    ],
+                    default: 'hide',
+                    description: 'What to do with the comment. Each action carries its own inverse, so there is no separate toggle: hide/unhide change its visibility, like/unlike react to it as the account, pin/unpin move it to the top of the thread.',
+                    displayOptions: { show: { resource: ['instagram'], operation: ['commentAction'] } },
+                },
+                {
+                    displayName: 'Post ID',
+                    name: 'commentActionPostId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'Native ID of the post the comment hangs from, as the platform assigns it (on TikTok, the video ID). Required to hide, unhide, pin or unpin; it is not sent for like or unlike, which the API rejects when it carries a post.',
+                    displayOptions: {
+                        show: {
+                            resource: ['instagram'],
+                            operation: ['commentAction'],
+                            commentModerationAction: ['hide', 'unhide', 'pin', 'unpin'],
                         },
                     },
                 },
@@ -1539,6 +1743,107 @@ class UploadPost {
                         },
                     },
                 },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Get Audience', value: 'getAudience', action: 'Get audience', description: 'Ask a connected network who follows the profile: audience countries, cities, age brackets and genders, how many followers are online each hour, daily followers gained and lost, profile actions and the bio. Platform says which network answers. Pass a Benchmark Category to also get that niche averages (comments, engagement rate, follower count and growth, likes, shares, video count and views) next to the numbers of the account; every response lists the 25 accepted categories in benchmark_categories. Use this to know WHO the audience is and WHEN to post; use Get Post Analytics for how a given post did.' },
+                        { name: 'Get Suggestions', value: 'getSuggestions', action: 'Get suggestions', description: 'Ask a connected network what to write about: hashtags (each with its view count) or the searches people run, around a seed word. Type picks which of the two, Platform says which network answers. Use this before writing a caption to pick hashtags or find the wording an audience searches for.' },
+                    ],
+                    default: 'getAudience',
+                    displayOptions: { show: { resource: ['insights'] } },
+                },
+                {
+                    displayName: 'User Identifier Name or ID',
+                    name: 'insightsUser',
+                    type: 'options',
+                    noDataExpression: true,
+                    required: true,
+                    default: '',
+                    description: 'Upload-Post profile whose connected account answers the question. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    typeOptions: { loadOptionsMethod: 'getUserProfiles' },
+                    displayOptions: { show: { resource: ['insights'] } },
+                },
+                {
+                    displayName: 'Platform',
+                    name: 'insightsPlatform',
+                    type: 'options',
+                    required: true,
+                    options: [
+                        { name: 'TikTok', value: 'tiktok' },
+                    ],
+                    default: 'tiktok',
+                    description: 'Network that answers the question. TikTok is the network that answers this question today; any other one replies with platform_not_supported and the list of the ones that can. On TikTok the profile needs the "profile_analytics" capability (see the capabilities array returned by List Users).',
+                    displayOptions: { show: { resource: ['insights'] } },
+                },
+                {
+                    displayName: 'Start Date',
+                    name: 'audienceStartDate',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'YYYY-MM-DD',
+                    description: 'First day of the window. The server clamps the range to 60 days at most and always below today, so a wider window is trimmed instead of rejected. Leave empty for the default range.',
+                    displayOptions: { show: { resource: ['insights'], operation: ['getAudience'] } },
+                },
+                {
+                    displayName: 'End Date',
+                    name: 'audienceEndDate',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'YYYY-MM-DD',
+                    description: 'Last day of the window. The server moves it below today, because there are no audience numbers for the current day yet.',
+                    displayOptions: { show: { resource: ['insights'], operation: ['getAudience'] } },
+                },
+                {
+                    displayName: 'Benchmark Category',
+                    name: 'audienceBenchmarkCategory',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'SOFTWARE_AND_APPS',
+                    description: 'Niche to compare the account against, which adds a benchmark object to the response. Leave empty to skip the comparison: the accepted values come back in benchmark_categories on every response anyway, so no extra call is needed to fill a picker.',
+                    displayOptions: { show: { resource: ['insights'], operation: ['getAudience'] } },
+                },
+                {
+                    displayName: 'Type',
+                    name: 'suggestionsType',
+                    type: 'options',
+                    required: true,
+                    options: [
+                        { name: 'Hashtags', value: 'hashtags' },
+                        { name: 'Keywords', value: 'keywords' },
+                    ],
+                    default: 'hashtags',
+                    description: 'Which suggestions you want. Hashtags answers with a list of name and view_count; keywords answers with the searches people run around the word.',
+                    displayOptions: { show: { resource: ['insights'], operation: ['getSuggestions'] } },
+                },
+                {
+                    displayName: 'Query',
+                    name: 'suggestionsQuery',
+                    type: 'string',
+                    default: '',
+                    description: 'Seed word to get suggestions around, written without the "#"',
+                    displayOptions: { show: { resource: ['insights'], operation: ['getSuggestions'] } },
+                },
+                {
+                    displayName: 'Country Code',
+                    name: 'suggestionsCountryCode',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'ES',
+                    description: 'ISO 3166-1 alpha-2 country to bias the suggestions towards, e.g. ES or US',
+                    displayOptions: { show: { resource: ['insights'], operation: ['getSuggestions'] } },
+                },
+                {
+                    displayName: 'Language',
+                    name: 'suggestionsLanguage',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'es',
+                    description: 'Language code to bias the suggestions towards, e.g. es or en',
+                    displayOptions: { show: { resource: ['insights'], operation: ['getSuggestions'] } },
+                },
                 {
                     displayName: 'User Identifier Name or ID',
                     name: 'user',
@@ -1593,7 +1898,7 @@ class UploadPost {
                     name: 'firstComment',
                     type: 'string',
                     default: '',
-                    description: 'Text to post as the first comment (or reply) immediately after publishing. Supported on Instagram, Facebook, X, Threads, YouTube, Reddit, Bluesky.',
+                    description: 'Text to post as the first comment (or reply) immediately after publishing. Supported on Instagram, Facebook, X, Threads, YouTube, Reddit, Bluesky, LinkedIn and TikTok. On TikTok the profile needs the "comments" capability (see the capabilities array returned by List Users).',
                     displayOptions: { show: { resource: ['uploads'], operation: ['uploadPhotos', 'uploadVideo', 'uploadText'] } },
                 },
                 {
@@ -1873,6 +2178,14 @@ class UploadPost {
                     description: 'Optional override for LinkedIn first comment. If provided, overrides the generic First Comment for LinkedIn.',
                     displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo', 'uploadText', 'uploadDocument'], platform: ['linkedin', '__manual_platform__'] } },
                 },
+                {
+                    displayName: 'TikTok First Comment (Override)',
+                    name: 'tiktokFirstComment',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional override for the TikTok first comment. If provided, overrides the generic First Comment for TikTok. The profile needs the "comments" capability (see the capabilities array returned by List Users); an account connected before that capability existed has to reconnect TikTok.',
+                    displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo'], platform: ['tiktok', '__manual_platform__'] } },
+                },
                 {
                     displayName: 'Photos (Files or URLs)',
                     name: 'photos',
@@ -2842,13 +3155,14 @@ class UploadPost {
                     name: 'tiktokPrivacyLevel',
                     type: 'options',
                     options: [
-                        { name: 'Public to Everyone', value: 'PUBLIC_TO_EVERYONE' },
-                        { name: 'Mutual Follow Friends', value: 'MUTUAL_FOLLOW_FRIENDS' },
+                        { name: 'Account Default', value: '' },
                         { name: 'Follower of Creator', value: 'FOLLOWER_OF_CREATOR' },
+                        { name: 'Mutual Follow Friends', value: 'MUTUAL_FOLLOW_FRIENDS' },
+                        { name: 'Public to Everyone', value: 'PUBLIC_TO_EVERYONE' },
                         { name: 'Self Only', value: 'SELF_ONLY' },
                     ],
-                    default: 'PUBLIC_TO_EVERYONE',
-                    description: 'Privacy setting for TikTok video (PUBLIC_TO_EVERYONE, MUTUAL_FOLLOW_FRIENDS, etc.). Only for Upload Video.',
+                    default: '',
+                    description: 'Privacy setting for the TikTok video. TikTok decides per account which levels are available: a private account has no Public to Everyone, and asking for one the account does not have fails with tiktok_privacy_unavailable listing the allowed ones. Account Default sends nothing and lets TikTok apply the account\'s own setting, which is the only value guaranteed to work on every account. Only for Upload Video.',
                     displayOptions: {
                         show: {
                             operation: ['uploadVideo'],
@@ -2951,6 +3265,140 @@ class UploadPost {
                         }
                     },
                 },
+                {
+                    displayName: 'TikTok Music ID',
+                    name: 'tiktokMusicId',
+                    type: 'string',
+                    default: '',
+                    description: 'Commercial Music Library track ID to add to the post: the ID field returned by the TikTok trending-music or music-search endpoint, not its commercial_music_id. To find a track by song or artist, call GET /api/uploadposts/tiktok/music/search from an HTTP Request node first. Works on video and photo posts alike, but a photo post takes the ID alone: the volume and trim options below are video-only. Needs the music capability on the TikTok connection (see capabilities in the user-profiles response); without it the field is ignored with a warning and the post still publishes. Leave empty to skip.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadPhotos'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Music Volume',
+                    name: 'tiktokMusicVolume',
+                    type: 'number',
+                    default: 50,
+                    typeOptions: { minValue: 0, maxValue: 100 },
+                    description: 'Volume (0-100) of the Commercial Music Library track. Only sent when a TikTok Music ID is set.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Music Start (Ms)',
+                    name: 'tiktokMusicStart',
+                    type: 'number',
+                    default: 0,
+                    typeOptions: { minValue: 0 },
+                    description: 'Start offset (ms) of the music track. Only sent when a TikTok Music ID is set and this is above 0.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Music End (Ms)',
+                    name: 'tiktokMusicEnd',
+                    type: 'number',
+                    default: 0,
+                    typeOptions: { minValue: 0 },
+                    description: 'End offset (ms) of the music track. Only sent when a TikTok Music ID is set and this is above 0.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Original Sound Volume',
+                    name: 'tiktokOriginalSoundVolume',
+                    type: 'number',
+                    default: 50,
+                    typeOptions: { minValue: 0, maxValue: 100 },
+                    description: 'Volume (0-100) of the original video audio when music is added. Only sent when a TikTok Music ID is set. Keep it above 0 so the original audio is not muted.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Location ID',
+                    name: 'tiktokLocationId',
+                    type: 'string',
+                    default: '',
+                    description: 'Location ID to tag on the post (video or photos). Needs the location capability on the TikTok connection (see capabilities in the user-profiles response) and a TikTok Location Name — the tag is only sent when both are filled in. Without the capability the field is ignored with a warning and the post still publishes. Leave empty to skip.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadPhotos'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Location Name',
+                    name: 'tiktokLocationName',
+                    type: 'string',
+                    default: '',
+                    description: 'Location name matching the TikTok Location ID. TikTok requires both together, so the location tag is only sent when this and the ID are both filled in.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadPhotos'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Cover Image URL',
+                    name: 'tiktokCoverImageUrl',
+                    type: 'string',
+                    default: '',
+                    description: 'Custom cover image URL for the video. Needs the cover_image capability on the TikTok connection (see capabilities in the user-profiles response); without it the field is ignored with a warning and the post still publishes. Takes priority over TikTok Cover Timestamp.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Is AI Generated',
+                    name: 'tiktokIsAiGenerated',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to disclose the post as AI-generated on TikTok. Works on video and photo posts. Only sent when enabled.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadPhotos'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Upload to Draft',
+                    name: 'tiktokUploadToDraft',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to send the video to TikTok drafts instead of publishing it. Needs the draft capability on the TikTok connection (see capabilities in the user-profiles response); without it the field is ignored with a warning and the post still publishes. When enabled TikTok ignores the rest of the post settings.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
                 {
                     displayName: 'Instagram Media Type',
                     name: 'instagramMediaType',