# Oss Insight Trending Repos Scraper (`kawsar/oss-insight-trending-repos-scraper`) Actor

Collect OSS Insight collections, repository membership, and star, fork, and language totals effortlessly. Export clean JSON, CSV, or Excel datasets for open-source research and tracking.

- **URL**: https://apify.com/kawsar/oss-insight-trending-repos-scraper.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## OSS Insight Trending Repos Scraper

![OSS Insight Trending Repos Scraper cover](https://images.bigibyte.com/cdn-cgi/image/width=1260,height=540,fit=cover,format=webp/apify-actors-covers/oss-insight-trending-repos-scraper-cover.png)

Keeping an eye on open-source projects usually means opening a lot of tabs and copying numbers into a spreadsheet by hand. This actor does that part for you. Give it a list of GitHub repositories in the simple `owner/repo` format, and it returns one clean row per repository with the current star count, fork count, open issue count, main programming language, and a direct link to the project. You can export the results as JSON, CSV, or Excel, feed them into your own reports, or run the actor again whenever you want a fresh snapshot. It is built for developers, analysts, founders, and researchers who want quick, reliable repository numbers without writing any code of their own.

### What you get

For every repository you add, the actor saves a single dataset row. Here is what each row contains:

- **recordId**: the unique number of the repository
- **name**: the short repository name
- **repoFullName**: the full name in `owner/repo` format
- **starsCount**: how many stars the repository has right now
- **forksCount**: how many times it has been forked
- **openIssuesCount**: the number of open issues
- **languageName**: the main programming language
- **htmlUrl**: the link to the repository page
- **scrapedAt**: the date and time the row was collected
- **error**: empty when everything went fine, or a short message when something did not

### How to use it

1. Open the actor and go to the **Input** tab.
2. Add one or more repositories to the **Repos** list, one per line, like `apify/crawlee`.
3. Leave the other settings as they are, or adjust them if you need to (see the table below).
4. Click **Start** and wait a few seconds.
5. Open the **Output** tab to view the table, or download it as JSON, CSV, or Excel.

### Input settings

| Setting | What it does | Default |
| --- | --- | --- |
| Repos | The repositories to look up, written as `owner/repo`. This is the only required field. | `apify/crawlee` |
| Delay between requests (s) | How many seconds to pause between requests. Raise it if you are checking a long list. | 1 |
| User-Agent | The name the actor shows when it makes a request. | `ActorResearch/1.0` |
| Run timeout (s) | The total time the actor is allowed to work. It stops cleanly before starting the next repository once this runs out. Between 30 and 3600. | 300 |
| Request timeout (s) | How long to wait for a single request before giving up on it. Between 5 and 300. | 30 |
| Proxy configuration | Optional. Leave it switched off unless you have a reason to use a proxy. | Off |

#### Input example

```json
{
  "repos": ["apify/crawlee"],
  "requestDelaySecs": 1,
  "userAgent": "ActorResearch/1.0",
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Output example

```json
{
  "recordId": "66670819",
  "name": "crawlee",
  "repoFullName": "apify/crawlee",
  "starsCount": 26273,
  "forksCount": 1733,
  "openIssuesCount": 150,
  "languageName": "TypeScript",
  "htmlUrl": "https://github.com/apify/crawlee",
  "mode": "repo",
  "scrapedAt": "2026-10-27T11:19:49.568076+00:00",
  "error": null
}
```

The dataset overview table shows `recordId`, `name`, `repoFullName`, `starsCount`, `forksCount` so you can scan your results at a glance.

### Common use cases

- **Open-source research**: collect star and fork numbers for the projects you are studying, all in one table.
- **Competitor tracking**: watch how rival projects grow by running the same list every week.
- **Reports and dashboards**: export the data to a spreadsheet or BI tool and build charts from it.
- **Scheduled snapshots**: set up an Apify schedule to keep a history of how your favorite repositories change over time.
- **Technology scouting**: compare the popularity and main language of several libraries before choosing one for a project.

### Tips for better results

- Write each repository exactly as `owner/repo`. Extra slashes, spaces, or full web links will be reported as an error row.
- Duplicates are skipped, so listing the same repository twice will not create two rows.
- If one repository in your list cannot be found, the rest still finish normally. Check the `error` column to see what went wrong.
- For very long lists, raise the run timeout so the actor has enough time to reach the end.

### Frequently asked questions

**Who is this actor for?**

Anyone who wants repository numbers in a tidy table. Developers, data analysts, open-source maintainers, and curious researchers all find it handy.

**What formats can I download?**

JSON, CSV, Excel, XML, HTML, and the other export formats Apify offers for datasets.

**How many repositories can I check in one run?**

There is no fixed limit in the actor itself. The practical limit is the run timeout, since the actor pauses briefly between requests. If your list is long, increase the run timeout or split it into a few runs.

**Can I run it on a schedule?**

Yes. Use Apify schedules to run it daily, weekly, or at any interval you like, and each run will add a fresh dataset.

**What happens if one repository fails?**

The run keeps going. The failed repository gets its own row with a short message in the `error` column, and every other repository is collected as usual.

**Why do some values come back empty?**

A field is left empty when no value is available for that repository. For example, a repository with no declared main language will have an empty `languageName`.

**Are the numbers live?**

They reflect the latest values at the moment of the run. The `scrapedAt` column tells you exactly when each row was collected.

**Do I need a proxy?**

Usually not. The proxy option is there if you need it, and it is switched off by default.

### Is web scraping legal?

Collecting openly available information is generally accepted in many places, but how you handle and use that information still matters. Here is how it applies to this actor:

- **What it collects**: this actor gathers repository facts such as names, star counts, fork counts, open issue counts, languages, and links. It does not collect personal details about individual people.
- **Your own data rules**: if you combine these results with other datasets that contain personal information, make sure you follow the privacy laws that apply to you, such as GDPR or CCPA.
- **Respect for the source**: keep your request volume reasonable, use the delay setting, and follow the usage terms of the original data provider and of GitHub.
- **Credit and licensing**: repository names, descriptions, and project content belong to their owners. Give credit where it is due, and check a project's license before reusing anything beyond the basic numbers.
- **Use it responsibly**: use the numbers for research, reporting, and analysis, and avoid anything that could harm the projects or their maintainers.

This section is general information only and is not legal advice. If you are unsure about a specific use, it is worth speaking with a qualified lawyer.

To read more, see Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

# Actor input Schema

## `repos` (type: `array`):

GitHub repositories in owner/repo format.

## `requestDelaySecs` (type: `number`):

Seconds to wait between requests.

## `userAgent` (type: `string`):

User-Agent header sent with each request.

## `timeoutSecs` (type: `integer`):

Overall run budget in seconds.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## `proxyConfiguration` (type: `object`):

Optional proxy. Leave off unless you need it.

## Actor input object example

```json
{
  "repos": [
    "apify/crawlee"
  ],
  "requestDelaySecs": 1,
  "userAgent": "ActorResearch/1.0",
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset rows in the overview table.

## `dataset` (type: `string`):

Full dataset for this run.

## `items` (type: `string`):

Dataset items as JSON.

# 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 = {
    "repos": [
        "apify/crawlee"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/oss-insight-trending-repos-scraper").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 = { "repos": ["apify/crawlee"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/oss-insight-trending-repos-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "repos": [
    "apify/crawlee"
  ]
}' |
apify call kawsar/oss-insight-trending-repos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/oss-insight-trending-repos-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/9eMtRdmiAePdHyCfz/builds/8HojFzG7cmS6su2YH/openapi.json