# Source Rights Indicator Extractor (`flintglade/source-rights-indicator-extractor`) Actor

Extract source-provided license, rights, attribution, robots, and policy indicators from explicit URLs with evidence locators—without making legal conclusions. $0.01 per completed URL check.

- **URL**: https://apify.com/flintglade/source-rights-indicator-extractor.md
- **Developed by:** [Flintglade](https://apify.com/flintglade) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 rights indicator checks

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Source Rights Indicator Extractor

Extract visible and machine-readable rights indicators from explicit URLs—metadata indicators only, not legal advice.

### What this does not do

This Actor does not give legal advice, declare reuse permitted or prohibited, interpret terms of service, crawl a site, treat robots directives as a license, or bypass access controls. It reads only explicit public or user-authorized URLs.

### Sources and authorization

Version 0.1 uses bounded HTTPS GET requests to each supplied URL. It examines safe response headers and HTML for `rel=license`, schema.org or Dublin Core rights metadata, copyright and attribution text, terms/privacy/API-policy links, robots metadata, and `X-Robots-Tag`. Optional policy retrieval is limited to five same-origin links identified by the source page.

### Input

Supply 1–1,000 explicit URLs. The controlled public default is:

```json
{
  "urls": ["https://flintglade-tools.github.io/apify-fixtures/rights/open-license.html"],
  "includeHeaders": true,
  "includeLinkedPolicies": false,
  "concurrency": 1
}
````

`maxHtmlBytes` is bounded between 1 KB and 5 MB. Version 0.1 supports HTTP retrieval only; browser rendering is intentionally excluded.

### Output

One result row is written per input URL, followed by an uncharged run-summary row. Each result contains:

- explicit status and substatus;
- response provenance and raw hash;
- indicators separated into license, copyright, attribution, robots, and policy categories;
- source values and evidence locators, with URL query values redacted;
- unresolved conflicts between license indicators;
- optional linked-policy evidence;
- `legalConclusion: null` and a fixed non-legal disclaimer.

Example finding:

```json
{
  "status": "ok",
  "data": {
    "substatus": "examined",
    "indicatorCounts": {"license": 1, "copyright": 1},
    "legalConclusion": null,
    "disclaimer": "Metadata indicators only—not legal advice or a conclusion that reuse is permitted or prohibited."
  }
}
```

### Pricing

The primary Apify pay-per-event event is `rights-indicator-check` at **$0.01 per input URL**. A successful examination, a page with no indicators, a conflicting-indicator result, or a definitive 404/410 is chargeable. Unsafe URLs, transient failures, rate-limit exhaustion, oversized pages, and parser invariant failures are uncharged. Linked policy pages are included in the input URL event and are never charged separately.

One URL check costs up to $0.01 in Actor events. Ten URL checks cost up to $0.10. One thousand URL checks cost up to $10.00, plus platform usage displayed by Apify. The Actor stops scheduling new URL checks when the run charge limit is reached.

### State

AP-029 is stateless. It does not create a baseline or silently retain monitoring history.

### Partial failures and negative results

Every URL receives its own deterministic status. One source failure does not convert another URL's evidence into a success. Duplicate URLs are emitted as uncharged rejected rows. A 404/410 is a chargeable terminal result because it is a definitive page examination; a 429, timeout, or 5xx is not.

### Resource limits

Launch settings are 256 MB minimum, 512 MB default, 1,024 MB maximum, and a 300-second timeout. Concurrency is bounded to 16, redirects are revalidated, and HTML is capped before parsing.

### Data handling and privacy

The Actor sends only the requested HTTPS reads to supplied origins and same-origin policy links when explicitly enabled. It has no external telemetry or database. Dataset and run-storage retention follow the customer's Apify account settings. URLs containing userinfo are rejected, URL query values are replaced with `REDACTED` in output, safe logs omit page bodies, and results never include cookies or authorization headers.

### Source rights and attribution

Outputs report source-provided indicators and their locations. An indicator may be incomplete, stale, conflicting, or legally insufficient. Customers remain responsible for authorization and legal review. The controlled Flintglade fixture is CC0 test infrastructure.

### Limitations

Version 0.1 does not execute JavaScript, resolve legal meaning, search external rights databases, or infer permission from robots rules. It may not observe indicators generated only after client-side rendering.

### Support and changelog

Support: `support@flintglade.com`. See `CHANGELOG.md` for release changes and `SOURCE_POLICY.md` for the source contract.

# Actor input Schema

## `inputSchemaVersion` (type: `integer`):

Versioned runtime input contract.

## `urls` (type: `array`):

Public or user-authorized HTTPS pages. Each URL can create one event.

## `includeHeaders` (type: `boolean`):

Inspect safe rights-related headers such as Link and X-Robots-Tag.

## `includeLinkedPolicies` (type: `boolean`):

Fetch at most five explicitly identified same-origin policy pages; these do not add events.

## `renderMode` (type: `string`):

Version 0.1 performs bounded HTTP retrieval only.

## `maxHtmlBytes` (type: `integer`):

Oversized responses are rejected and uncharged.

## `concurrency` (type: `integer`):

Bounded simultaneous URL reads; it does not change the event price.

## Actor input object example

```json
{
  "inputSchemaVersion": 1,
  "urls": [
    "https://flintglade-tools.github.io/apify-fixtures/rights/open-license.html"
  ],
  "includeHeaders": true,
  "includeLinkedPolicies": false,
  "renderMode": "http",
  "maxHtmlBytes": 2000000,
  "concurrency": 8
}
```

# Actor output Schema

## `defaultDataset` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://flintglade-tools.github.io/apify-fixtures/rights/open-license.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flintglade/source-rights-indicator-extractor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": ["https://flintglade-tools.github.io/apify-fixtures/rights/open-license.html"] }

# Run the Actor and wait for it to finish
run = client.actor("flintglade/source-rights-indicator-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://flintglade-tools.github.io/apify-fixtures/rights/open-license.html"
  ]
}' |
apify call flintglade/source-rights-indicator-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=flintglade/source-rights-indicator-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Source Rights Indicator Extractor",
        "description": "Extract source-provided license, rights, attribution, robots, and policy indicators from explicit URLs with evidence locators—without making legal conclusions. $0.01 per completed URL check.",
        "version": "0.1",
        "x-build-id": "I26T4wWsMYLuSL8IF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/flintglade~source-rights-indicator-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-flintglade-source-rights-indicator-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/flintglade~source-rights-indicator-extractor/runs": {
            "post": {
                "operationId": "runs-sync-flintglade-source-rights-indicator-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/flintglade~source-rights-indicator-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-flintglade-source-rights-indicator-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "inputSchemaVersion": {
                        "title": "Input schema version",
                        "minimum": 1,
                        "maximum": 1,
                        "type": "integer",
                        "description": "Versioned runtime input contract.",
                        "default": 1
                    },
                    "urls": {
                        "title": "Explicit URLs",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Public or user-authorized HTTPS pages. Each URL can create one event.",
                        "items": {
                            "type": "string",
                            "maxLength": 2048
                        }
                    },
                    "includeHeaders": {
                        "title": "Include safe response headers",
                        "type": "boolean",
                        "description": "Inspect safe rights-related headers such as Link and X-Robots-Tag.",
                        "default": true
                    },
                    "includeLinkedPolicies": {
                        "title": "Inspect linked policies",
                        "type": "boolean",
                        "description": "Fetch at most five explicitly identified same-origin policy pages; these do not add events.",
                        "default": false
                    },
                    "renderMode": {
                        "title": "Render mode",
                        "enum": [
                            "http"
                        ],
                        "type": "string",
                        "description": "Version 0.1 performs bounded HTTP retrieval only.",
                        "default": "http"
                    },
                    "maxHtmlBytes": {
                        "title": "Maximum HTML bytes",
                        "minimum": 1024,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Oversized responses are rejected and uncharged.",
                        "default": 2000000
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Bounded simultaneous URL reads; it does not change the event price.",
                        "default": 8
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
