What to do if you get an error when uploading a feed

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because the attributes are formed incorrectly.

1. Open the feed in a text editor and locate elements that contain attributes.

2. Check the syntax of the attributes: they should be specified in the format attribute=""value"", with the value enclosed in quotes.

3. Make sure that:

   • there are no missing or extra quotes;
   • attributes do not overlap or are not nested incorrectly;
   • all special characters in attribute values are escaped or represented as entities (e.g., & instead of &).

4. Check that each element does not contain duplicate attributes with the same names.

5. Use XML or YML validators to automatically detect incorrectly formed attributes and other errors in the feed.

6. If the feed is generated programmatically, check the code that creates the attributes and make sure it generates them in accordance with the format requirements.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly due to the absence of a closing quote (") or apostrophe (') in one of the attributes.

1. Open the feed in a text editor and carefully check all attributes in the tags.
2. Make sure that every opening quote has a corresponding closing quote.
3. Use tools for checking XML or YML syntax to automatically detect mismatched quotes and other characters.
4. If you edited the feed manually, double-check the sections of code that were last modified — the error might be there.
5. After fixing the quotes, save the file and make sure the changes haven’t introduced other errors in the feed structure.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly due to an incorrect redefinition of the HTTP header.

1. Open the feed in a text editor and find the section where HTTP headers are defined.
2. Check if there are any duplicate or incorrectly set headers in the feed.
3. Make sure the syntax used for defining the headers complies with the requirements of the format (XML, YML, etc.).
4. Compare the current header values with the feed format documentation — perhaps one of the values is set incorrectly.
5. Use XML or YML validators to check the feed for errors in headers and other elements.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly due to an improperly closed CDATA section.

1. Open the feed in a text editor and locate the CDATA sections.
2. Check that each CDATA section starts with <![CDATA[ and ends with ]]>.
3. Make sure there are no unclosed tags or other characters in the CDATA sections that could interfere with the proper closure of the section.
4. If special characters (e.g., ]) are used in the CDATA sections, ensure they are properly escaped and do not cause the section to close prematurely.
5. Use XML or YML validators to check the feed for errors in CDATA sections and other elements.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly due to the presence of an invalid character.

1. Open the feed in a text editor and review its contents, paying special attention to special characters and symbols.
2. Check whether the characters used are within the allowed range for the file format (XML, YML, etc.). Some characters may be invalid in certain contexts.
3. Use the search function in the editor to find suspicious characters that might be causing the error.
4. If the feed contains text in multiple languages, make sure the file encoding meets the requirements (e.g., UTF-8) and that all characters are displayed correctly.
5. Use XML or YML validators to automatically detect invalid characters and other errors in the feed.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly due to the presence of an invalid character code.

1. Open the feed in a text editor and locate areas where character references are used (e.g., &, <, etc.).
2. Check that all character references are correct and comply with the standards for the file format being used (XML, YML, etc.).
3. Make sure there are no incorrectly encoded or corrupted character references in the feed.
4. Use the search function in the editor to find all occurrences of character references and check them for errors.
5. Use XML or YML validators to automatically detect invalid character references and other errors in the feed.
6. If the feed contains text in multiple languages, make sure the file encoding meets the requirements (e.g., UTF-8) and that all characters are displayed correctly.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly due to an unterminated comment.

1. Open the feed in a text editor and locate all comments. In XML and YML, comments are enclosed between <!-- and -->.
2. Check that each comment is properly closed — for every <!--, there is a corresponding -->.
3. Make sure there are no syntax errors or invalid characters inside the comments that could interfere with their closure.
4. Use the search function in the editor to find all comments and check them for any unclosed tags.
5. Use XML or YML validators to automatically detect unterminated comments and other errors in the feed.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly due to an improperly terminated DOCTYPE declaration.

1. Open the feed in a text editor and locate the DOCTYPE declaration — it is usually at the very beginning of the file.
2. Check the syntax of the DOCTYPE declaration: it must be properly formed and comply with the standard for the document type being used (e.g., XML or HTML).
3. Make sure there are no extra characters, typos, or incorrect formatting in the DOCTYPE declaration.
4. Compare the current DOCTYPE declaration with a correct example for your document type, which can be found in the official documentation.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because the document is empty.

1. Open the feed in a text editor and check whether the file contains any data.
2. Make sure the file has not been accidentally deleted or overwritten with an empty one.
3. Check the file path — you might be trying to open the wrong document.
4. If the feed is generated programmatically, check the code responsible for creating the file — here might be an error causing the file to remain empty.
5. Try regenerating the feed if possible.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because the DOCTYPE declaration is formed incorrectly.

1. Open the feed in a text editor and locate the DOCTYPE declaration — it is usually at the very beginning of the file.
2. Check the syntax of the DOCTYPE declaration: it must be properly formed and comply with the standard for the document type being used (e.g., XML or HTML).
3. Make sure all necessary components are correctly specified in the DOCTYPE declaration, such as the document type name and the DTD reference (if required).
4. Compare the current DOCTYPE declaration with a correct example for your document type, which can be found in the official documentation.
5. Check for any extra characters, typos, or incorrect formatting in the declaration.
6. Use XML or HTML validators to automatically check the DOCTYPE declaration and other elements of the feed for errors.
7. If the feed is generated programmatically, check the code that creates the DOCTYPE declaration and make sure it generates a valid declaration.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because a closing tag is missing at the specified location.

1. Open the feed in a text editor and navigate to the indicated line and column to locate the element with the missing closing tag.

2. Verify tag pairing. Make sure that every opening tag (<tag>) has a corresponding closing tag (</tag>).

3. Check tag consistency and nesting. Ensure that:

   • the tag names in opening and closing tags match exactly;
   • tags are properly nested (i.e., inner tags are closed before outer tags).

4. Use the editor’s search function to verify that all closing tags are present and correctly positioned.

5. Leverage XML/YML validators. Use online or standalone XML/YML validation tools to automatically detect missing closing tags and other feed errors.

6. Consider XML visualization tools (if the feed structure is complex). These tools can help you visually identify unclosed tags by displaying the hierarchical structure of your XML.

7. Review the code (if the feed is generated programmatically). Check the code responsible for generating the tags to ensure it properly adds corresponding closing tags.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because an entity is not defined in the XML.

1. Open the feed in a text editor and locate mentions of entities — they are usually denoted as &entityname;.
2. Check whether all used entities are defined in the DOCTYPE section or an external DTD file.
3. Make sure the entity names are correct and match those defined in the DTD.
4. If you are using external DTD files, check that they are correctly linked and accessible.
5. If an entity is no longer needed, remove its mentions from the file.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because an entity reference in the XML is not terminated with a semicolon (;).

1. Open the feed in a text editor and locate all mentions of entities — they are usually denoted as &entityname;.
2. Check that each entity reference is terminated with a semicolon. The absence of ; at the end of the reference can cause a parsing error.
3. Use the search function in the editor to find all occurrences of & and verify that entity references are properly formatted.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because an entity name is not specified in the indicated location. It is also possible that an HTML file was loaded instead of an RSS file, or the & symbol is not properly encoded.

1. Open the feed in a text editor and go to the specified line and column to locate the place where the entity name is missing.
2. Check that entity references are used correctly in this place. They should be specified in the format &entityname;.
3. Make sure that the URL actually points to an RSS file and not an HTML file.
4. Check the URL and correct it if necessary.
5. Find all occurrences of the & symbol in the RSS file and ensure that it is encoded as &.
6. Use the search function in the editor to check all occurrences of the & symbol and make sure they are properly encoded.
7. Use XML or RSS validators to automatically detect missing entity names, incorrect use of the & symbol, and other errors in the feed.
8. If the feed is generated programmatically, check the code that creates the file and make sure all entities and special symbols are correctly implemented.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because it failed to read an attribute name.

1. Open the feed in a text editor and locate elements that contain attributes.
2. Check attribute names for invalid characters. Attribute names should not contain spaces, punctuation marks, or certain special characters.
3. Make sure attribute names comply with the syntax rules of XML or YML — they should start with a letter or an underscore and can contain letters, numbers, hyphens, underscores, and some other characters.
4. Check that attribute names do not overlap with reserved words or names that have special meanings in the format being used.
5. Use the search function in the editor to check all attributes for invalid names.
6. Use XML or YML validators to automatically detect attributes with invalid names and other errors in the feed.
7. If the feed is generated programmatically, check the code that creates the attributes and make sure it generates valid names.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because a > symbol is missing in one of the tags.

1. Open the feed in a text editor and review its contents, paying special attention to the tags.
2. Locate the tag that is missing the closing > symbol and add it.
3. Check that all opening and closing tags are properly formed and contain the necessary symbols.
4. Use the search function in the editor to check all occurrences of < and make sure that appropriate content and a > symbol follow them.
5. Use XML or YML validators to automatically detect tags without the > symbol and other errors in the feed.
6. If the feed is generated programmatically, check the code that creates the tags and make sure it adds a > symbol at the end of each tag.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because unexpected content was found at the end of the document.

1. Open the feed in a text editor and carefully review the contents, paying special attention to the end of the file.
2. Check if there are any extraneous characters, tags, or code fragments after the main content that should not be there.
3. Make sure all tags are properly closed and the document structure complies with the requirements of the format (XML, YML, etc.).
4. Use the search function in the editor to find any suspicious elements that might be located at the end of the file.
5. Use XML or YML validators to automatically detect extraneous content and other errors in the feed.
6. If the feed is generated programmatically, check the code responsible for file generation — there might be an error causing additional data to be appended to the end of the file.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because the document cannot be read in UTF-8 encoding. It is likely that the file uses a different encoding, and the correct one needs to be specified.

1. Open the feed in a text editor that supports viewing and changing the encoding (e.g., Notepad++ or Sublime Text).
2. Check the current encoding of the file and determine which encoding is being used.
3. Convert the file to UTF-8. In most text editors, this can be done via the Save As or Encoding menu.
4. Make sure the correct encoding is specified at the beginning of the file (in the XML declaration). For example: <?xml version=""1.0"" encoding=""UTF-8""?>.
5. If the feed is generated programmatically, check the settings responsible for the output file’s encoding and ensure it is set to UTF-8.
6. Use online services or tools to check file encoding to verify that the file has been correctly converted to UTF-8.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because the opening and closing tags do not match.

1. Open the feed in a text editor and locate the line where the error was detected (the line number is indicated in the error message).
2. Check that there is a corresponding closing tag (</tag>) for each opening tag (<tag>).
3. Make sure the tag names in the opening and closing tags match. For example, if there is an opening tag <title>, there should be a corresponding closing tag </title>, not </name>.
4. Use the search function in the editor to find all occurrences of the problematic tag and check their pairs.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because an unknown character with a specific code was found in the PCDATA block.

1. Open the feed in a text editor and locate the PCDATA block where the error was detected. You can use the search function by character code or visually inspect the file, paying attention to unusual characters.
2. Check which characters are used in the PCDATA block. Some characters may be invalid in this context.
3. Make sure the file encoding meets the requirements (e.g., UTF-8) and all characters are displayed correctly.
4. If special characters are used in the PCDATA block, check whether they need to be escaped or replaced with corresponding entities (e.g., < instead of <).
5. Use XML or YML validators to automatically detect invalid characters and other errors in the feed.
6. If the feed contains text in multiple languages, make sure all characters are supported by the chosen encoding and displayed correctly.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because the document type is not specified.

1. Open the feed in a text editor and locate the section where the document type is usually specified. In XML files, this is often done through the prolog or special processing instructions (Processing Instructions, PI).
2. Make sure the XML prolog correctly specifies the document type, for example, through the DOCTYPE declaration or other relevant instructions.
3. Check that the file begins with a valid XML declaration, such as <?xml version=""1.0"" encoding=""UTF-8""?>.
4. If processing instructions (PIs) are used, ensure that the target element (target name) is correctly specified in them. For example, in the instruction <?xml-stylesheet type=""text/xsl"" href=""style.xsl""?>, the target element is xml-stylesheet.
5. Compare the structure of your file with the requirements of the format you are using (XML, RSS, etc.) to ensure that all necessary elements are present.
6. Use XML or RSS validators to automatically check for the presence of the document type declaration and other elements in the feed for errors.
7. If the feed is generated programmatically, check the code that creates the prolog and processing instructions, and make sure the document type is specified correctly.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because data in a tag is terminated prematurely.

1. Open the feed in a text editor and go to the line where the error was detected (the line number is indicated in the error message).
2. Check that all data within the tag is fully specified and the tag is properly closed.
3. Make sure there are no unfinished elements or attributes in the tag that could cause the data to end prematurely.
4. Use the search function in the editor to check for all necessary closing tags and ensure they are correctly placed.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because it contains an invalid sequence of characters or elements.

1. Open the feed in a text editor and locate the place where the invalid sequence is indicated (information about the sequence is provided in the error message).
2. Check whether the order of elements and attributes in the feed complies with the requirements of the format (XML, YML, etc.).
3. Make sure there are no nested elements that are not allowed in the given context and that all elements are in the correct places within the hierarchy.
4. Compare the feed structure with the official documentation or examples of correct files for your format.
5. Use XML or YML validators to automatically detect invalid sequences and other errors in the feed.
6. If the feed is generated programmatically, check the code that creates the file structure — there might be an error causing the incorrect sequence of elements.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because there is no required space after the PUBLIC declaration.

1. Open the feed in a text editor and locate the place where the PUBLIC declaration is used.
2. Check if there is a space after the word PUBLIC. If there is no space, add it.
3. Make sure the rest of the declaration is correctly formatted and complies with the requirements of the format (XML, YML, etc.).
4. Use XML or YML validators to automatically check the PUBLIC declaration and other elements of the feed for errors.
5. If the feed is generated programmatically, check the code that creates this declaration and make sure it adds the required space.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because the specified attribute is missing a required value.

1. Open the feed in a text editor and locate the attribute in question (its name is indicated in the error message).
2. Check if a value is specified for this attribute. The attribute should be written in the format attribute="value".
3. If a value is missing, add it, taking into account the format requirements and functionality of the feed.
4. Make sure the attribute value is correct in terms of syntax and content.
5. Use XML or YML validators to automatically check the attributes and other elements of the feed for errors.
6. If the feed is generated programmatically, check the code that creates the attributes and make sure all required values are set correctly.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because an opening tag was not found.

1. Open the feed in a text editor and analyze the file structure.
2. Check that each element starts with an opening tag of the form <tag>.
3. Make sure there is a root element at the beginning of the file that encloses all other feed elements.
4. Use the search function in the editor to check for all expected opening tags.
5. Use XML or YML validators to automatically detect missing opening tags and other errors in the feed.
6. If the feed structure is complex, consider using tools for visualizing the XML structure, which can help you clearly see any missing elements.
7. If the feed is generated programmatically, check the code that creates the file structure — there might be an error preventing the opening tag from being added.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because an invalid opening tag name was used in the specified location.

1. Open the feed in a text editor and go to the specified line and column to find the problematic tag.

2. Check that the tag name complies with XML or YML naming rules:

   • the name must not contain spaces, punctuation marks (except for hyphens and underscores) and certain special characters;
   • it must start with a letter or an underscore;
   • make sure there are no typos in the tag name and that it does not match reserved words that have special meanings in the format being used.

3. Compare the tag you are using with the format requirements and the structure that should be in the feed.

4. Use the search function in the editor to check all opening tags for name correctness.

5. Use XML or YML validators to automatically detect invalid tag names and other errors in the feed.

6. If the feed is generated programmatically, check the code that creates the tags and make sure it generates valid names.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because a symbol that needs to be escaped is present in an attribute value.

1. Open the feed in a text editor and locate the attribute where the invalid symbol is detected (the symbol is indicated in the error message).
2. Check which symbols in attribute values need to be escaped. For example, symbols like &, <, > and some others should be replaced with corresponding entities (e.g., &, <, >).
3. Escape the necessary symbols in attribute values according to XML or YML standards.
4. Use the search function in the editor to check all attribute values for other symbols that may need escaping.
5. Use XML or YML validators to automatically detect unescaped symbols and other errors in the feed.
6. If the feed contains text in multiple languages or special characters, make sure all of them are properly escaped or represented as entities.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because an unsupported XML version is used.

1. Open the feed in a text editor and locate the XML version declaration — it is usually at the very beginning of the file, for example: <?xml version="1.0" encoding="UTF-8"?>.
2. Check which XML version is specified in the declaration. Make sure it is supported by the system that processes your feed.
3. If an unsupported version is used, change it to a more common and supported one (e.g., XML 1.0).
4. After changing the XML version, make sure the rest of the feed code is compatible with the new version.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot process the file correctly because the XML declaration is not at the beginning of the document.

1. Open the feed in a text editor and locate the XML declaration — it usually looks like this: <?xml version="1.0" encoding="UTF-8"?>.
2. Make sure the XML declaration is at the very beginning of the file, before any other elements or text.
3. If the XML declaration is not at the beginning of the file, move it to the first line of the document.
4. Check if there are any other XML declarations or extraneous characters in the file before the main content.
5. Use XML validators to check the file structure and ensure the XML declaration is correctly placed.
6. If the feed is generated programmatically, check the code that forms the beginning of the file and make sure the XML declaration is added to the first line.

Description

How to Fix

A parsing error was detected when checking your feed. The system cannot load the file correctly because the HTTP status code received from the server is not 200 (OK).

1. Check the server response status. Use the testing tool to inspect the HTTP status code.

2. Verify the feed URL. Confirm that the URL is correct and points to an existing feed file. Double-check for typos or incorrect paths.

3. Review server access restrictions. Check for any server-side settings that might block access to the feed, such as:

   • IP-based access restrictions;
   • misconfigured .htaccess rules;
   • web server (e.g., Apache, Nginx) access controls.

4. Ensure the feed file is publicly accessible. Make sure the file is not protected by:

   • password authentication (e.g., HTTP Basic Auth);
   • other access-control mechanisms (e.g., login gates, CDN restrictions).

5. Examine server logs. Check your server’s error and access logs for clues about why a non-200 status is being returned. Look for:

   • 4xx (client errors) or 5xx (server errors);
   • timestamps matching feed retrieval attempts.

6. Validate the SSL certificate (if applicable). If the feed URL uses HTTPS:

   • confirm the SSL/TLS certificate is valid and not expired;
   • ensure there are no certificate mismatches or chain issues;
   • test the certificate using an online SSL checker.

7. Test the feed URL in a browser. Open the feed URL directly in a web browser to:

   • verify it loads without errors;
   • confirm it returns the expected feed content (e.g., XML, YML);
   • check the HTTP status in the browser’s developer tools (Network tab).

Description

How to Fix

The URL in a critical tag (e.g., <link>, <guid>, <enclosure url="..." />, <media url="..." />) contains syntax errors that make it unparseable or inaccessible.

1. Locate the invalid URL.
2. Add the protocol. Ensure the URL starts with https://.
3. Check syntax and characters.
4. Validate domain and path. Confirm the domain is correct (e.g., example.com, not exmple.com). Ensure the path exists (e.g., /article/123, not /articel/123).
5. Use absolute URLs. Replace relative paths (/page) with full URLs (https://example.com/page).
6. Test the URL. Paste the full URL into a browser — confirm it loads the intended page.
7. Ensure public accessibility. The URL must be reachable without login, paywall, or IP restrictions.

Description

How to Fix

The publication date is in an invalid format. The system cannot parse the date.

1. Check the value of the <pubDate> tag in the affected <item>.

2. Rewrite the date in RFC 5322 format: EEE, dd MMM yyyy HH:mm:ss GMT.

3. Verify the following:

   • Weekdays (EEE) — abbreviated, capitalized (Mon, Tue, ..., Sun);
   • Months (MMM) — abbreviated, capitalized (Jan, Feb, ..., Dec);
   • Time zone — GMT only (not UTC, not local time);
   • All required symbols are present (commas, spaces, colons).

Description

How to Fix

The URL provided in the <link> tag of an RSS <item> is invalid. This prevents systems from accessing the article, which may lead to:

• failed indexing;
• broken links in feed readers;
• content not appearing in search results.

1. Locate the invalid URL.

2. Ensure absolute URL format.

   Every <link> must start with https://.

3. Verify URL syntax. All special characters are properly escaped:

   • & → &;
   • < → <;
   • > → >.

4. Test the URL.

   Open it in a browser — check for 404, redirects, or login prompts.

Description

How to Fix

The lang attribute (which indicates the language of the content) contains an invalid or improperly formatted value. This prevents systems from:

• correctly localizing the content;
• displaying items in language‑based filters;
• meeting platform requirements for language tagging.

1. Locate the lang attribute.

2. Verify the value.

   Use only two‑letter ISO 639‑1 codes.

3. Check formatting:

   • The value must be in lowercase.
   • Enclose the value in quotes: lang="tr".
   • No extra spaces or characters inside the quotes.

4. Remove invalid variants and non‑existent codes (e.g., xyz, abc).

Description

How to Fix

The URL provided for the logo is invalid. This prevents the system from displaying the logo in search results, feeds, or other interfaces.

1. Locate the logo URL: find the <yandex:logo url="..." /> tag in your RSS feed.

2. Verify URL syntax.

   Ensure it starts with https://.

   All special characters are properly escaped:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL. Open it in a browser — check if the image loads (no 404/500 errors).

4. Confirm image accessibility:

   The image must be publicly accessible (no login, paywall, or IP restriction).

   Avoid internal/staging URLs.

5. Check image format and size.

6. Fix path and domain.

   Correct any typos in the domain or path.

   Use absolute URLs (e.g., https://example.com/logo.png), not relative paths.

Description

How to Fix

The type attribute within the <enclosure> tag contains an invalid or incorrectly formatted MIME type. This prevents systems from properly identifying and handling the enclosed media file (e.g., audio, video, images).

1. Locate the <enclosure> tag.

2. Verify the MIME type format.

   Use only valid MIME types (see official list: IANA MIME Types). Common examples:

   • audio/mpeg — MP3 audio;
   • video/mp4 — MP4 video;
   • image/jpeg — JPEG image;
   • image/png — PNG image;
   • application/pdf — PDF document.

3. Ensure correct syntax:

   • Format: type="<type>/<subtype>" (e.g., type="audio/mpeg").
   • All characters must be lowercase.
   • No extra spaces or symbols inside the quotes.
   • Properly escape special characters if needed (e.g., & → &).

4. Replace invalid values.

5. Check the URL.

   Confirm the url attribute points to a working resource (test in browser).

   Ensure the file type matches the declared MIME type.

Description

How to Fix

The url attribute in the <enclosure> tag contains an invalid, broken, or inaccessible link.

1. Locate the <enclosure> tag.

2. Verify URL syntax.

   Ensure it starts with https://.

   All special characters must be properly escaped:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL directly. Paste the full URL into a browser — confirm the file loads without errors.

4. Ensure public accessibility.

   The file must be reachable without login, paywall, or IP restrictions.

   Avoid staging/internal URLs.

5. Check file existence and location:

   Confirm the file still exists at the specified path.

   If moved, update the URL to the new location.

   Use absolute URLs.

6. Replace relative paths (e.g., /media/file.mp3) with full URLs (e.g., https://example.com/media/file.mp3).

7. Validate MIME type.

Description

How to Fix

The URL pointing to an online media stream (e.g., live audio/video feed) is invalid or inaccessible.

1. Locate the stream URL.

2. Verify URL syntax.

   Ensure it starts with https://.

   Escape all special characters:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL directly. Paste the full URL into a media player (e.g., VLC, browser) — confirm the stream plays.

4. Ensure public accessibility:

   The stream must be reachable without login, paywall, or IP restrictions.

   Avoid internal/staging URLs.

5. Check stream server status. Confirm the streaming server is online and operational.

6. Validate stream endpoint:

   Double‑check the port, path, and query parameters in the URL.

   If using tokens/keys, ensure they’re still valid and not expired.

7. Use absolute URLs. Replace relative paths (e.g., /stream/live) with full URLs (e.g., https://example.com/stream/live).

Description

How to Fix

The URL pointing to a video player (e.g., embedded player, web‑based player, or player API endpoint) is invalid or inaccessible.

1. Locate the player URL.

2. Verify URL syntax.

   Ensure it starts with https://.

   Escape all special characters:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL directly. Paste the full URL into a browser — confirm the player loads and functions.

4. Ensure public accessibility.

   The player must be reachable without login, paywall, or IP restrictions.

   Avoid internal/staging URLs.

5. Check player server status. Confirm the player hosting server is online and operational.

6. Validate player endpoint.

   Double‑check the path, query parameters, and API version in the URL.

   If using tokens/keys, ensure they’re valid and not expired.

7. Use absolute URLs. Replace relative paths (e.g., /player/embed) with full URLs (e.g., https://example.com/player/embed).

Description

How to Fix

The URL in a tag meant for related/external content (e.g., <link rel="related">, custom <relatedUrl>, or similar) is invalid or inaccessible.

1. Locate the related URL.

2. Verify URL syntax.

   Ensure it starts with https://.

   Escape all special characters:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL directly. Paste the full URL into a browser — confirm the page loads without errors.

4. Ensure public accessibility.

   The page must be reachable without login, paywall, or IP restrictions.

   Avoid internal/staging URLs.

5. Check target page status.

   Confirm the linked page still exists at the specified URL.

   If moved, update the link to the new location.

6. Use absolute URLs. Replace relative paths (e.g., /resources/guide) with full URLs (e.g., https://example.com/resources/guide).

7. Validate query parameters.

   If the URL includes tokens/keys, ensure they’re valid and not expired.

   Remove unnecessary tracking parameters (e.g., utm_* if not required).

Description

How to Fix

The URL pointing to a video thumbnail image is invalid or inaccessible.

1. Locate the thumbnail URL.

2. Verify URL syntax:

   Ensure it starts with https://.
   Escape all special characters:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL directly. Paste the full URL into a browser — confirm the image loads without errors.

4. Ensure public accessibility.

   The image must be reachable without login, paywall, or IP restrictions.

   Avoid internal/staging URLs.

5. Check image file status.

   Confirm the image still exists at the specified path.

   If moved, update the URL to the new location.

6. Use absolute URLs. Replace relative paths (e.g., /img/thumb.jpg) with full URLs (e.g., https://example.com/img/thumb.jpg).

7. Validate image format and size.

   Supported formats: image/jpeg, image/png, image/gif, image/svg+xml.

   Optimize images for fast loading (compress if needed).

8. Confirm MIME type (if applicable).

Description

How to Fix

An XML attribute intended to contain a URL (e.g., url, href, src, link, or platform specific variants) has an invalid, malformed, or inaccessible value.

1. Locate the invalid attribute.

2. Verify URL syntax.

   Ensure it starts with https://.

   Check for properly closed quotes: url="https://example.com" (not url=https://example.com).

   Escape special characters:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL directly. Paste the full URL into a browser — confirm it loads without errors.

4. Ensure public accessibility.

   The resource must be reachable without login, paywall, or IP restrictions.

   Avoid internal/staging URLs.

5. Use absolute URLs. Replace relative paths (e.g., /page.html) with full URLs (e.g., https://example.com/page.html).

6. Check query parameters.

   Remove unnecessary tracking params (e.g., utm_* if not required).

   Confirm tokens/keys are valid and not expired.

Description

How to Fix

The URL pointing to a video file (or video stream) is invalid, malformed, or inaccessible.

1. Locate the video URL.

2. Verify URL syntax.

   Ensure it starts with https://.

   Escape all special characters:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL directly. Paste the full URL into a video player (e.g., VLC, browser) — confirm the video plays.

4. Ensure public accessibility.

   The video must be reachable without login, paywall, or IP restrictions.

   Avoid internal/staging URLs.

5. Check video file status.

   Confirm the file still exists at the specified path.

   If moved, update the URL to the new location.

6. Use absolute URLs. Replace relative paths (e.g., /videos/clip.mp4) with full URLs (e.g., https://example.com/videos/clip.mp4).

7. Validate video format and MIME type.

8. Confirm streaming compatibility (if applicable).

   For live streams, verify the endpoint is active and accepts connections.

   Test with a streaming player (e.g., HLS/DASH testers).

Description

How to Fix

The system could not automatically detect the MIME type (content type) of the media file referenced in your feed (e.g., video, audio, image, document).

1. Locate the media tag.

2. Add or correct the type attribute.

   Specify the correct MIME type in the type attribute.

   Use standard MIME types.

3. Check the actual file.

   Download the file from the URL and verify its format (e.g., open in a media player or image viewer).

   Confirm the file extension matches the declared MIME type.

4. Ensure direct file links.

   The URL should point directly to the media file (not a landing page or redirect).

   Avoid scripts that serve files without proper headers.

5. Fix server/CDN config (if needed).

Description

How to Fix

The article title exceeds the maximum allowed length of 200 characters.

1. Locate the <title> tag.

2. Count the characters. Verify the title exceeds 200 chars (include spaces and punctuation).

3. Shorten the title.

   Remove redundant words, filler phrases, or marketing text.

   Keep the core message: who, what, when, where.

   Use abbreviations only if widely understood.

   Prioritize clarity and impact.

   Focus on the main subject or hook.

   Avoid including dates, author names, or categories.

   Use natural language.

   Don’t sacrifice readability for brevity — ensure the shortened title still makes sense.

4. Check for hidden characters. Remove extra spaces, tabs, or non printing characters that inflate length.

Description

How to Fix

An XML element in your feed contains the same attribute twice (e.g., two href attributes in a <link> tag). This violates XML standards and causes parsing errors.

1. Locate the duplicate attribute.

2. Remove the duplicate.

   Keep only one instance of the attribute.

   Decide which value is correct (e.g., prefer https:// over http://, or the canonical URL over a backup).

3. Verify correctness. Ensure the retained attribute value is valid (correct URL, proper MIME type, etc.).

4. Check that no other attributes are missing.

   Check surrounding elements.

   Scan nearby tags for similar duplication issues.

Description

How to Fix

HTML special characters (e.g., <, >, &, ") have been escaped twice in your feed content (typically inside <description>, <content:encoded>, or CDATA sections).

1. Locate the double escaped content.

   Open your feed file and find fields like <description>, <content:encoded>.

   Look for sequences like &, <, etc.

2. Unescape once.

   Replace double escaped patterns with their correct single escaped form:

   • & → &;
   • < → <;
   • > → >;
   • " → ".

Description

How to Fix

The <media:group> element in your feed contains another <media:group> as a child tag, which is not allowed by the Media RSS (MRSS) specification. <media:group> is a container for media items (e.g., <media:content>, <media:thumbnail>), but it must not nest another <media:group> inside it. This creates invalid XML structure and prevents proper parsing of media assets.

1. Locate the <media:group> tags.

2. Check for nested <media:group>.

   Look for any <media:group> that contains another <media:group> as a direct child.

3. Remove the nested <media:group>.

   Extract its child elements (e.g., <media:content>, <media:thumbnail>).

   Move them to the parent <media:group>.

4. Flatten the structure.

   All media items (content, thumbnails, etc.) should be direct children of a single <media:group>.

   No nesting of <media:group> within <media:group>.

5. Verify media item validity.

   Ensure each <media:content> has required attributes: url, type, duration (if video).

   Check <media:thumbnail> has url and optional width/height.

6. Ensure well formed XML.

   Close all tags properly.

   Quote all attribute values.

   Escape special characters (& → &, etc.).

Description

How to Fix

The <media:group> element in your feed is missing required child tags. According to the Media RSS (MRSS) specification, each <media:group> must contain at least one of:

• <media:content> (direct media file/stream);
• <media:player> (embedded player URL).

Without these, the media group is empty and cannot be processed — systems ignore it or reject the item entirely.

1. Locate the <media:group> tags.

2. Check for required children.

   Verify each <media:group> contains at least one: <media:content>; or <media:player>.

3. Add missing <media:content> (recommended).

   Include url (absolute URL to media file), type (MIME type), and duration (in seconds, if video).

   1. Or add <media:player> (if using embedded player).

      Use url attribute with the player’s embed URL.

4. Ensure valid media URLs:

   Test each url in a browser/player to confirm accessibility.

   Avoid internal/staging links.

5. Keep other metadata.

   Retain <media:thumbnail>, <media:title>, etc., but only after adding <media:content>/<media:player>.

6. Validate XML syntax.

Description

How to Fix

The <media:group> element in your feed includes multiple <media:player> tags. This violates the Media RSS specification, which allows only one <media:player> per <media:group>.

1. Locate the <media:group> tags.

2. Identify multiple <media:player> instances.

   Look for groups with two or more <media:player> child tags.

3. Keep only one <media:player>:

   Choose the primary player URL (e.g., most compatible, highest quality, or default platform player).

   Remove all other <media:player> tags from the group.

4. Validate the retained player URL:

   Test the url attribute in a browser — ensure it loads the player correctly.

   Confirm it’s an absolute URL (starts with https://).

Description

How to Fix

The feed item lacks a required URL pointing to the full article.

1. Locate the affected <item>.

   Open your feed file and find the item with the missing URL.

2. Add or restore the <link> tag.

   Insert a <link> element inside the <item>.

3. Ensure URL validity.

4. Remove empty tags: <link></link> → replace with valid URL.

5. Fix malformed URLs (e.g., example.com/article → https://example.com/article).

Description

How to Fix

The required lang attribute — specifying the language of the content — is absent from a critical element in your feed.

1. Locate the element needing lang.

2. Add the lang attribute. Insert lang="xx" into the opening tag, where xx is the correct ISO 639‑1 code.

3. Use valid ISO 639‑1 codes. Always lowercase.

4. Apply at the right level.

   Feed level: Use lang on <rss>/<feed> if all items share the same language.

   Item level: Add lang to individual <item> if languages vary.

   Field level: Include on specific content tags (e.g., <description lang="es">) if language differs within an item.

5. Ensure correct syntax:

   Attribute value must be quoted: lang="en" (not lang=en).
   No extra spaces or characters inside the quotes.

   Only one lang per element (don’t repeat).

Description

How to Fix

The <pubDate> tag — which specifies the publication date and time of the article — is missing from the <item> in your RSS/XML feed.

1. Locate the affected <item>.

   Open your feed file and find items without a <pubDate>.

2. Add the <pubDate> tag.

   Insert <pubDate>[date]</pubDate> inside the <item>, typically after <title> and <link>.

3. Use RFC 5322 format.

   The date must follow the standard: EEE, dd MMM yyyy HH:mm:ss GMT.

Description

How to Fix

The feed item lacks the full body text of the article.

1. Locate the affected <item>.

   Open your feed file and find items with missing or empty text content.

2. Add the full article text.

   Include the complete body of the article (all paragraphs, headings, lists, etc.).

Description

How to Fix

The <title> tag is missing from an <item> in your RSS/XML feed.

1. Locate the affected <item>.

   Open your feed file and find items without a <title> tag.

2. Add the <title> tag.

   Insert <title>Your Article Title Here</title> inside the <item>, typically as the first child element.

Description

How to Fix

The URL provided for the mobile version of the article is invalid or inaccessible. This prevents mobile users from being directed to the optimized version of your content.

1. Locate the mobile URL tag.

2. Verify URL syntax.

   Ensure it starts with https:// (preferred) or http://.

   All special characters are properly escaped:

   • & → &;
   • < → <;
   • > → >.

3. Test the URL directly.

   Paste the full URL into a mobile browser — confirm it loads the mobile version without errors.

4. Ensure public accessibility:

   The mobile page must be reachable without login, paywall, or IP restrictions.

   Avoid internal/staging URLs.

5. Confirm mobile optimization:

   Verify the page is truly optimized for mobile (responsive design, fast loading, touch friendly).

   Check it on multiple mobile devices/browsers.

6. Confirm tokens/keys are valid and not expired.

Description

How to Fix

The <pubDate> value in your RSS/XML feed is set to a future date (later than the current UTC time).

1. Locate the invalid <pubDate>.

2. Verify current UTC time.

3. Update <pubDate> to the actual publication time.

   Use the real release date/time when the article became publicly available.

Description

How to Fix

The article's text content (in <description>, <yandex:full-text>, or equivalent) contains too few words.

1. Locate the affected <item>. Open your feed file and find items with very short or zero text content.

2. Expand the content.

   Include the full article text (all paragraphs, headings, lists).

   Avoid truncation — ensure the complete story is present.

3. Replace placeholders:

   Remove phrases like: “Read the full article here”, “Click for details”, “More on our website”.

   Replace with actual content.

4. Use the correct tag for full text.

5. Ensure readability.

Description

How to Fix

The URL in the <link> (or equivalent) tag of your feed item exceeds the maximum allowed length set by the platform.

1. Locate the long <link>. Open your feed file and find items with excessively long URLs.

2. Measure the length. Count characters in the href/url value (including https:// and query params).

3. Shorten the URL (maximum 243 characters).

   Use shorter, clean paths (e.g., /article/123 instead of /category/subcat/year/month/title/version/lang/...).

   Consolidate parameters — merge redundant or duplicate keys.

4. Validate the shortened URL.

   Test it in a browser — ensure it redirects to the correct page.