Feed report

The Feed report shows details about the latest ingestion attempt for your feed. This includes the overall status, availability status for each file that comprises the feed, and the count and status of all entities found in the feed. You can view a history of all feed ingestions for this feed in the past 90 days. Each feed in the property will have a separate feed report.

If your property has only one feed, the Feed report will be labeled simply Feed. If your property has multiple feeds, each will have its own Feed report, labeled with the feed's unique name.

 

Open Search Console

FAQs

Here's how to find the most commonly needed information about your feed:

Status of the latest ingestion

Open your feed report to see the feed status at the top of the page. If the feed failed for file-level issues, you will see the issues listed in the Feed files section. If the failure was due to another cause, you'll need to speak to your Google representative to learn why.
Last successful ingestion
Check the latest ingestion status at the top of the Feed report. If the ingestion was not successful, click View history to see your ingestion history, to find the most recent successful ingestion.

See your ingestion history

Click View ingestion history to see your ingestion history to see a list of all ingestion attempts for the past 90 days.

Number of entities in a given status

To find the number of entities in a given status in the latest ingestion, find the Detected entities table at the bottom of the landing page in the Feed report and total up the items in the appropriate column (Valid, Valid with warnings, Invalid).
To find the number of items in a given status in a previous ingestion, you'll need to click into each row of the Detected entities table to see the entity history, and total up the items in a given state for a given date on the chart.

Status history for a given entity type

To see a history of a given entity type, click the appropriate row in the Detected entities table at the bottom of the landing page in the Feed report. Each point in the history chart represents an ingestion.

Number of entities in Google

If the latest ingestion was successful, find the Detected entities table at the bottom of the landing page in the Feed report and total up the items in the Valid and Valid with warnings columns.
If the latest ingestion was not successful:
  1. Click View ingestion history on the landing page of the Feed report and find the most recent successful ingestion in the ingestion history. Note the date and time of the ingestion.
  2. Go back to the Feed report landing page, and find the Detected entities table.
  3. Click into each row in the table (except the Other entities row)
  4. Select Valid and Valid with warnings above the chart, and deselect Invalid.
  5. Find the date and time that you recorded in step 1.
  6. Total up the numbers for each item type in the Detected entities table.
All entities with a specific issue
To find all entities with a specific issue:
  1. Find the Detected entities table in the Feed report
  2. Click an entity type to see a table of issues with that type. Look for a specific issue in the issues table.
  3. Click the row in the issues table to see a non-comprehensive list of entities affected by that issue.
Because issues are categorized by fairly fine-grained properties that vary by entity type, there is no way to search for broad issues (for example, missing "name" property) across all entity types.

Entity issues in the latest ingestion

To see a list of entity issues in the latest ingestion, find the Detected entities table at the bottom of the landing page in the Feed report.
To investigate an issue:
  1. Click a row in the table to see a history of entities of that type.
  2. Select Invalid or Valid with warnings at the top of the chart to see a list of issues affecting your feed.
  3. Click any row with an Entities count value greater than 0 to see a list of entities affected by that issue. (If the count is 0, the issue has been resolved in the latest ingestion, but if the latest ingestion failed, the issue might have been present in the last successful ingestion.)
  4. Click an entity in the example entities table to see the erroneous code. Note that the example entities table might not show all entities affected by an issue.

Ingestion status

At the top of the Feed report, you will see a verdict for the latest ingestion attempt. This is dependent on many factors, including the ability to request and parse the files, and the validity of the entities found in the feed. If there is one file-level issue or too many entity issues in the feed, the ingestion will fail.

It can take a few hours for an ingestion to appear in the Feed report. Although most ingestions are regularly scheduled, a few feed ingestions might be triggered automatically for various reasons.

Live feed statuses

The following statuses are available for a feed marked Live:

  • Data processed and pushed to Google
    The feed passed validation. All valid entities in the feed have potentially been entered into the Knowledge Graph. This verdict implies that at least one valid entity was detected in the feed. A valid entity in a successful feed is not guaranteed to be entered in the Knowledge Graph. Also, some invalid entities might still be entered into the Knowledge Graph, if the error was minor or fixable. Read more.
  • Data processed, but can’t be pushed to Google
    The ingestion was rejected, either because of entity inconsistencies, a dramatic change in the number of valid entities since the last ingestion, or some other reason. Please speak to your feeds contact at Google to learn what happened, and how to fix this issue. Valid entities from the last successful feed will remain active in the Knowledge Graph.
  • Data processing failed: feed file issues
    The ingestion was rejected because of file-level issues. No entities from this feed will be pushed to the Knowledge Graph. No entities from this ingestion will be shown in the Detected entities section of the Feed report. Entities shown are from the last ingestion that was either valid or "Data processed, but can't be pushed to Google".
  • Data processing failed: empty feed
    All feed files were either empty or contained no parsable entities. If entities exist but all have errors, that is a case of Data processed but can't be pushed to Google.

Non-live feed statuses

The following statuses are available for a non-live feed:

  • Data processed
    Google can read, parse, and do an initial validation of your feed. Examine and fix any warning or error issues found in the feed, as shown in the entities table on the Feed report.
  • Data processing failed: empty feed
    All feed files were either empty or contained no parsable entities.
  • Data processing failed: feed file issues
    The ingestion was rejected because of file-level issues. No entities from this ingestion will be shown in the Detected entities section of the Feed report.

Other information

"Live" badge
A "Live" badge will appear on a feed after it has been successfully pushed to Google at least once.
Time
The ingestion time reported by the verdict is the (user-local) time when Google fetched the first file in the feed.

Feed files

The Feed files section shows whether the files in your feed could be read. If any file cannot be read, then the ingestion will fail.

Feed file issues

The following file-level errors can occur:

  • Not found (404): Feed file wasn't found at the URL provided.
  • Blocked due to unauthorized request (401): Be sure to include any auth information required for Google to access the file in your feed configuration.
  • Blocked by robots.txt: A robots.txt rule is blocking the feed. Find and modify or remove the rule.
  • Server error (5xx): A server error occurred when trying to read your feed file.
  • Redirect error: A redirection error of some sort for the file, such as a redirection loop or a redirect to an invalid URL (not a valid but non-responsive URL). The feed file reader will follow redirects, but if your feed file permanently moves, you should update your feed file settings rather than specifying a redirect.
  • Blocked due to access forbidden (403): Google wasn't allowed to read your file because of an access restriction. Be sure to include any auth information required for Google to access the file in your feed configuration.
  • Blocked due to other 4xx issue: Some other issue prevented Google from being able to access this feed file.
  • Parsing issue: A fatal parsing issue prevented the entire file from being read. Click the issue description to see a snippet containing the parse error.
  • Internal error: Google had an unspecified problem and will try again later.
  • DNS server unresponsive: The DNS server did not respond to our request. Google will periodically retry to read your feed.
  • DNS error: Host unknown: The DNS service did not understand the feed URL you provided. Hopefully this is a transient error, but check the provided URL to be sure.
  • DNS error: Private IP provided: The DNS service returned a DNS returned an IP address reserved for private addresses (such as 10.0.0.1). Contact your DNS service provider.
  • Server connection error: A 5XX-level error occurred (the server was unreachable, refused connection or failed to respond).
  • Server invalid response: The server does not support requested protocol, response / headers were truncated, or the response could not be parsed (perhaps because of a compression error).
  • Invalid server SSL certificate: The site's SSL certificate is invalid. Google will not process requests when the SSL certificate is invalid.
  • Fetched but not processed: If any file in the feed could not be fetched or processed, Google will try to fetch the remaining files but not process them, and feed ingestion will fail. "Fetched but not processed" is the label given to any successfully fetched files in this situation.

Detected entities

This section shows all top-level entities for your vertical detected in this ingestion, grouped by type.

If the ingestion failed, the entities shown in the Detected entities section were not pushed to Google, and the entities from your last successful ingestion remain in Google. In this case, use the entity information shown in Detected entities to help you debug the feed.

Top-level entities table

For each top-level entity type, the table shows the number of entities by status. To see details for an entity type, click the entity row in the table to open the entity details page.

If an ingestion failed because no files can be read, the values in the table will all be zero, but you can still click an entity row to see the ingestion history for that entity type. Remember that Google continues to serve entities from the last successful ingestion.

Other entities

The Other entities type, if shown, lists entities that could not be properly typed, either because they were missing a type description, or because duplicate entities existed in that feed with the same ID. Entities that cannot be parsed are not included in the reports at all.

Entity details page

Click a row in the feed's entities table to see details for the clicked entity type.

Entity ingestion history chart

The history chart for an entity type shows the number of entities of that type in each status for each ingestion. The data points in the chart are ingestions, successful or not. The chart does not show the inventory on Google, but rather the number of entities in a given state for a given ingestion.

Although the chart shows upward or downward slopes between ingestion points, any changes are instantaneous at the time of the ingestion, so you might think of it as a bar chart rather than a line chart, with each bar being the width of time from one ingestion to the next.

Chart annotations mark failed ingestions. If no files could be read, the chart will drop to zero for all statuses for that ingestion.

Entities table

The table shows status details for the chosen entity type from the latest ingestion attempt.

  1. Click a row in the table to see more information about entities with that status and description, including a list of example entity (limited to 1,000 entities), and a history chart of entities with that status and description.
  2. Click an example entity in the table to see more details, including the entity code with the error highlighted (if possible).

Entity status

An issue is classified into one of the following statuses. An entity is classified according to the most severe issue it contains. So in an entity has two issues, one Invalid and one Valid with warnings, the entity status is Invalid.

  • Invalid: This entity cannot be used as provided in the feed. Please update the entity for the next feed ingestion if you want it to be eligible for use. If the feed status is successful and this is a live feed, the invalid entity will be removed from Google.
  • Valid with warnings: This entity can be used as provided; however there is something you might want to fix. The warning could be about something that you should change (for example, use of a deprecated field) or might want to provide for extra information (for example, prices). Some of these issues might become errors in the future.
  • Valid: These entities are eligible for inclusion in the Knowledge Graph. To see a list of valid entities, click View data about valid entities below the graph in the summary page of the feed report.

Debugging your feed

Debugging a feed is an iterative process. Use the Feeds report to find and fix bugs, then track your fixes in the next feed ingestion in the report.

Issues are grouped by top-level entity type. You can probably fix many, if not all, issues of a specific type by examining the issue in one instance and fixing your entity generation code.

To validate an individual item, you can use the Data Feed Validation tool.

To fix entity issues:

  1. Look at the list of entity types in the table at the bottom of the Feed report. Click a row that shows more than zero Invalid items.
  2. Make sure that the Invalid tab is selected to see a history of entities in error state in your feeds.
  3. Look at the list of errors in the error details table at the bottom of the report.
  4. Click into an error to see a history of entities with that error, and examples of entities with that error in the latest ingestion attempt. The example entity list is not necessarily complete for various reasons; however the count of entities affected by this error shown in the chart should be complete.
  5. Click an entity in the example list to see the code with the error highlighted (highlighting is not supported for all errors). Click the Learn more link to learn more about that error. In some cases you may see a suggestion for a fix in the additional information panel. You should also read the documentation for your specific entity to learn what the required value or format is.
  6. Generate an updated feed, and check your fix on a formerly broken entity or two using the Data Feed Validation tool.
  7. If all looks good, update your feed and wait for the next ingestion to see if those errors have gone away. You can check the history of a specific error type in a specific entity type by clicking the entity type in the Feed report Detected Entities table, then clicking an issue in the Details table.

Issue types

A feed can have feed issues and entity issues.

  • Feed issues involve reading and parsing the file. Any file issues will cause an ingestion to fail. See a list of file issues.
  • Entity issues can be syntax errors or missing required fields. Entity issues can also be problems reconciling an entity in a feed with an entity in the Knowledge graph. Learn more

Entity issues

An entity can have one or more issues, and/or multiple instances of the same issue. To debug an entity issue, click into the report for the latest feed to see errors and warnings, then click down into specific entities to see an example list of entities affected by a specific issue.

Entity issue types

Entities can have parsing/compliance issues or matching issues. The Feed report does not distinguish between these two classes of issues, but knowing the issue class can help with fixing the issue:

  • Parsing or compliance issues mean that the entity can't be parsed, is missing required values, or has unsupported values for a given field. For these types of issues, read the issue name to understand the problem, and read the documentation for the specific entity type to see what's required for the given entity.
  • [Experimental] Matching issues occur when Google is unable to match an entity in your feed to an entity in the Knowledge Graph. This happens mainly because we are missing data about the feed entity or some of the information about the feed entity does not match the information we have about this entity in Google. Triggers for these issues are still being developed, so you should focus on fixing parsing or compliance issues first. Learn how to debug matching issues.

Was this helpful?

How can we improve it?
true
New to Search Console?

Never used Search Console before? Start here, whether you're a complete beginner, an SEO expert, or a website developer.

Search
Clear search
Close search
Google apps
Main menu
6705039339812116803
true
Search Help Center
true
true
true
true
true
83844